@xpert-ai/plugin-sdk 3.6.7 → 3.7.1

package/index.cjs.js

@@ -4,10 +4,15 @@ var common = require('@nestjs/common');
 var constants = require('@nestjs/common/constants');
 var lodashEs = require('lodash-es');
 var core = require('@nestjs/core');
+var contracts = require('@metad/contracts');
+var node_async_hooks = require('node:async_hooks');
+var passportJwt = require('passport-jwt');
+var jsonwebtoken = require('jsonwebtoken');
+var node_crypto = require('node:crypto');
+var cqrs = require('@nestjs/cqrs');
 var fs = require('fs');
 var http = require('http');
 var https = require('https');
-var contracts = require('@metad/contracts');
 var tools = require('@langchain/core/tools');
 var zod = require('zod');
 var fsPromises = require('fs/promises');
@@ -15,10 +20,6 @@ var path = require('path');
 var i18next = require('i18next');
 var FsBackend = require('i18next-fs-backend');
 var yaml = require('yaml');
-var node_async_hooks = require('node:async_hooks');
-var passportJwt = require('passport-jwt');
-var jsonwebtoken = require('jsonwebtoken');
-var node_crypto = require('node:crypto');
 var _axios = require('axios');
 var openai = require('@langchain/openai');
 var documents = require('@langchain/core/documents');
@@ -83,6 +84,11 @@ var _axios__namespace = /*#__PURE__*/_interopNamespaceDefault(_axios);
     };
 }
 
+const ORGANIZATION_METADATA_KEY = 'xpert:organizationId';
+const PLUGIN_METADATA_KEY = 'xpert:pluginName';
+const GLOBAL_ORGANIZATION_SCOPE = 'global';
+const STRATEGY_META_KEY = 'XPERT_STRATEGY_META_KEY';
+
 function _extends() {
     _extends = Object.assign || function assign(target) {
         for(var i = 1; i < arguments.length; i++){
@@ -114,8 +120,46 @@ function createPluginLogger(scope, baseMeta = {}) {
 }
 
 const INTEGRATION_STRATEGY = 'INTEGRATION_STRATEGY';
-const IntegrationStrategyKey = (provider)=>common.SetMetadata(INTEGRATION_STRATEGY, provider);
-
+const IntegrationStrategyKey = (provider)=>common.applyDecorators(common.SetMetadata(INTEGRATION_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, INTEGRATION_STRATEGY));
+
+/******************************************************************************
+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 */ function _instanceof$2(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var extendStatics = function extendStatics1(d, b) {
+    extendStatics = Object.setPrototypeOf || _instanceof$2({
+        __proto__: []
+    }, Array) && function(d, b) {
+        d.__proto__ = b;
+    } || function(d, b) {
+        for(var p in b)if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+    };
+    return extendStatics(d, b);
+};
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+        this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -125,40 +169,1104 @@ function __decorate(decorators, target, key, desc) {
 function __metadata(metadataKey, metadataValue) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 }
+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 next() {
+            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));
+}
 typeof SuppressedError === "function" ? SuppressedError : function _SuppressedError(error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function isFunction(value) {
+    return typeof value === "function";
+}
+
+function createErrorClass(createImpl) {
+    var _super = function _super(instance) {
+        Error.call(instance);
+        instance.stack = new Error().stack;
+    };
+    var ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+}
+
+var UnsubscriptionError = createErrorClass(function(_super) {
+    return function UnsubscriptionErrorImpl(errors) {
+        _super(this);
+        this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+            return i + 1 + ") " + err.toString();
+        }).join("\n  ") : "";
+        this.name = "UnsubscriptionError";
+        this.errors = errors;
+    };
+});
+
+function arrRemove(arr, item) {
+    if (arr) {
+        var index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
+    }
+}
+
+function _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var Subscription = function() {
+    function Subscription(initialTeardown) {
+        this.initialTeardown = initialTeardown;
+        this.closed = false;
+        this._parentage = null;
+        this._finalizers = null;
+    }
+    Subscription.prototype.unsubscribe = function() {
+        var e_1, _a, e_2, _b;
+        var errors;
+        if (!this.closed) {
+            this.closed = true;
+            var _parentage = this._parentage;
+            if (_parentage) {
+                this._parentage = null;
+                if (Array.isArray(_parentage)) {
+                    try {
+                        for(var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()){
+                            var parent_1 = _parentage_1_1.value;
+                            parent_1.remove(this);
+                        }
+                    } catch (e_1_1) {
+                        e_1 = {
+                            error: e_1_1
+                        };
+                    } finally{
+                        try {
+                            if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+                        } finally{
+                            if (e_1) throw e_1.error;
+                        }
+                    }
+                } else {
+                    _parentage.remove(this);
+                }
+            }
+            var initialFinalizer = this.initialTeardown;
+            if (isFunction(initialFinalizer)) {
+                try {
+                    initialFinalizer();
+                } catch (e) {
+                    errors = _instanceof$1(e, UnsubscriptionError) ? e.errors : [
+                        e
+                    ];
+                }
+            }
+            var _finalizers = this._finalizers;
+            if (_finalizers) {
+                this._finalizers = null;
+                try {
+                    for(var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()){
+                        var finalizer = _finalizers_1_1.value;
+                        try {
+                            execFinalizer(finalizer);
+                        } catch (err) {
+                            errors = errors !== null && errors !== void 0 ? errors : [];
+                            if (_instanceof$1(err, UnsubscriptionError)) {
+                                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                            } else {
+                                errors.push(err);
+                            }
+                        }
+                    }
+                } catch (e_2_1) {
+                    e_2 = {
+                        error: e_2_1
+                    };
+                } finally{
+                    try {
+                        if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+                    } finally{
+                        if (e_2) throw e_2.error;
+                    }
+                }
+            }
+            if (errors) {
+                throw new UnsubscriptionError(errors);
+            }
+        }
+    };
+    Subscription.prototype.add = function(teardown) {
+        var _a;
+        if (teardown && teardown !== this) {
+            if (this.closed) {
+                execFinalizer(teardown);
+            } else {
+                if (_instanceof$1(teardown, Subscription)) {
+                    if (teardown.closed || teardown._hasParent(this)) {
+                        return;
+                    }
+                    teardown._addParent(this);
+                }
+                (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+            }
+        }
+    };
+    Subscription.prototype._hasParent = function(parent) {
+        var _parentage = this._parentage;
+        return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+    };
+    Subscription.prototype._addParent = function(parent) {
+        var _parentage = this._parentage;
+        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [
+            _parentage,
+            parent
+        ] : parent;
+    };
+    Subscription.prototype._removeParent = function(parent) {
+        var _parentage = this._parentage;
+        if (_parentage === parent) {
+            this._parentage = null;
+        } else if (Array.isArray(_parentage)) {
+            arrRemove(_parentage, parent);
+        }
+    };
+    Subscription.prototype.remove = function(teardown) {
+        var _finalizers = this._finalizers;
+        _finalizers && arrRemove(_finalizers, teardown);
+        if (_instanceof$1(teardown, Subscription)) {
+            teardown._removeParent(this);
+        }
+    };
+    Subscription.EMPTY = function() {
+        var empty = new Subscription();
+        empty.closed = true;
+        return empty;
+    }();
+    return Subscription;
+}();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+    return _instanceof$1(value, Subscription) || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+    if (isFunction(finalizer)) {
+        finalizer();
+    } else {
+        finalizer.unsubscribe();
+    }
+}
+
+var config = {
+    Promise: undefined};
+
+var timeoutProvider = {
+    setTimeout: function setTimeout1(handler, timeout) {
+        var args = [];
+        for(var _i = 2; _i < arguments.length; _i++){
+            args[_i - 2] = arguments[_i];
+        }
+        return setTimeout.apply(void 0, __spreadArray([
+            handler,
+            timeout
+        ], __read(args)));
+    },
+    clearTimeout: function clearTimeout1(handle) {
+        return (clearTimeout)(handle);
+    },
+    delegate: undefined
+};
+
+function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(function() {
+        {
+            throw err;
+        }
+    });
+}
+
+function noop() {}
+
+function errorContext(cb) {
+    {
+        cb();
+    }
+}
+
+var Subscriber = function(_super) {
+    __extends(Subscriber, _super);
+    function Subscriber(destination) {
+        var _this = _super.call(this) || this;
+        _this.isStopped = false;
+        if (destination) {
+            _this.destination = destination;
+            if (isSubscription(destination)) {
+                destination.add(_this);
+            }
+        } else {
+            _this.destination = EMPTY_OBSERVER;
+        }
+        return _this;
+    }
+    Subscriber.create = function(next, error, complete) {
+        return new SafeSubscriber(next, error, complete);
+    };
+    Subscriber.prototype.next = function(value) {
+        if (this.isStopped) ; else {
+            this._next(value);
+        }
+    };
+    Subscriber.prototype.error = function(err) {
+        if (this.isStopped) ; else {
+            this.isStopped = true;
+            this._error(err);
+        }
+    };
+    Subscriber.prototype.complete = function() {
+        if (this.isStopped) ; else {
+            this.isStopped = true;
+            this._complete();
+        }
+    };
+    Subscriber.prototype.unsubscribe = function() {
+        if (!this.closed) {
+            this.isStopped = true;
+            _super.prototype.unsubscribe.call(this);
+            this.destination = null;
+        }
+    };
+    Subscriber.prototype._next = function(value) {
+        this.destination.next(value);
+    };
+    Subscriber.prototype._error = function(err) {
+        try {
+            this.destination.error(err);
+        } finally{
+            this.unsubscribe();
+        }
+    };
+    Subscriber.prototype._complete = function() {
+        try {
+            this.destination.complete();
+        } finally{
+            this.unsubscribe();
+        }
+    };
+    return Subscriber;
+}(Subscription);
+var ConsumerObserver = function() {
+    function ConsumerObserver(partialObserver) {
+        this.partialObserver = partialObserver;
+    }
+    ConsumerObserver.prototype.next = function(value) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.next) {
+            try {
+                partialObserver.next(value);
+            } catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    };
+    ConsumerObserver.prototype.error = function(err) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.error) {
+            try {
+                partialObserver.error(err);
+            } catch (error) {
+                handleUnhandledError(error);
+            }
+        } else {
+            handleUnhandledError(err);
+        }
+    };
+    ConsumerObserver.prototype.complete = function() {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.complete) {
+            try {
+                partialObserver.complete();
+            } catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    };
+    return ConsumerObserver;
+}();
+var SafeSubscriber = function(_super) {
+    __extends(SafeSubscriber, _super);
+    function SafeSubscriber(observerOrNext, error, complete) {
+        var _this = _super.call(this) || this;
+        var partialObserver;
+        if (isFunction(observerOrNext) || !observerOrNext) {
+            partialObserver = {
+                next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined,
+                error: error !== null && error !== void 0 ? error : undefined,
+                complete: complete !== null && complete !== void 0 ? complete : undefined
+            };
+        } else {
+            {
+                partialObserver = observerOrNext;
+            }
+        }
+        _this.destination = new ConsumerObserver(partialObserver);
+        return _this;
+    }
+    return SafeSubscriber;
+}(Subscriber);
+function handleUnhandledError(error) {
+    {
+        reportUnhandledError(error);
+    }
+}
+function defaultErrorHandler(err) {
+    throw err;
+}
+var EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop
+};
+
+var observable = function() {
+    return typeof Symbol === "function" && Symbol.observable || "@@observable";
+}();
+
+function identity(x) {
+    return x;
+}
+
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce(function(prev, fn) {
+            return fn(prev);
+        }, input);
+    };
+}
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+var Observable = function() {
+    function Observable(subscribe) {
+        if (subscribe) {
+            this._subscribe = subscribe;
+        }
+    }
+    Observable.prototype.lift = function(operator) {
+        var observable = new Observable();
+        observable.source = this;
+        observable.operator = operator;
+        return observable;
+    };
+    Observable.prototype.subscribe = function(observerOrNext, error, complete) {
+        var _this = this;
+        var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+        errorContext(function() {
+            var _a = _this, operator = _a.operator, source = _a.source;
+            subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+        });
+        return subscriber;
+    };
+    Observable.prototype._trySubscribe = function(sink) {
+        try {
+            return this._subscribe(sink);
+        } catch (err) {
+            sink.error(err);
+        }
+    };
+    Observable.prototype.forEach = function(next, promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function(resolve, reject) {
+            var subscriber = new SafeSubscriber({
+                next: function next1(value) {
+                    try {
+                        next(value);
+                    } catch (err) {
+                        reject(err);
+                        subscriber.unsubscribe();
+                    }
+                },
+                error: reject,
+                complete: resolve
+            });
+            _this.subscribe(subscriber);
+        });
+    };
+    Observable.prototype._subscribe = function(subscriber) {
+        var _a;
+        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    };
+    Observable.prototype[observable] = function() {
+        return this;
+    };
+    Observable.prototype.pipe = function() {
+        var operations = [];
+        for(var _i = 0; _i < arguments.length; _i++){
+            operations[_i] = arguments[_i];
+        }
+        return pipeFromArray(operations)(this);
+    };
+    Observable.prototype.toPromise = function(promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function(resolve, reject) {
+            var value;
+            _this.subscribe(function(x) {
+                return value = x;
+            }, function(err) {
+                return reject(err);
+            }, function() {
+                return resolve(value);
+            });
+        });
+    };
+    Observable.create = function(subscribe) {
+        return new Observable(subscribe);
+    };
+    return Observable;
+}();
+function getPromiseCtor(promiseCtor) {
+    var _a;
+    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+    return value && _instanceof(value, Subscriber) || isObserver(value) && isSubscription(value);
+}
+
+function hasLift(source) {
+    return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+    return function(source) {
+        if (hasLift(source)) {
+            return source.lift(function(liftedSource) {
+                try {
+                    return init(liftedSource, this);
+                } catch (err) {
+                    this.error(err);
+                }
+            });
+        }
+        throw new TypeError("Unable to lift unknown Observable type");
+    };
+}
+
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+    return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function(_super) {
+    __extends(OperatorSubscriber, _super);
+    function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+        var _this = _super.call(this, destination) || this;
+        _this.onFinalize = onFinalize;
+        _this.shouldUnsubscribe = shouldUnsubscribe;
+        _this._next = onNext ? function(value) {
+            try {
+                onNext(value);
+            } catch (err) {
+                destination.error(err);
+            }
+        } : _super.prototype._next;
+        _this._error = onError ? function(err) {
+            try {
+                onError(err);
+            } catch (err) {
+                destination.error(err);
+            } finally{
+                this.unsubscribe();
+            }
+        } : _super.prototype._error;
+        _this._complete = onComplete ? function() {
+            try {
+                onComplete();
+            } catch (err) {
+                destination.error(err);
+            } finally{
+                this.unsubscribe();
+            }
+        } : _super.prototype._complete;
+        return _this;
+    }
+    OperatorSubscriber.prototype.unsubscribe = function() {
+        var _a;
+        if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+            var closed_1 = this.closed;
+            _super.prototype.unsubscribe.call(this);
+            !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+        }
+    };
+    return OperatorSubscriber;
+}(Subscriber);
+
+var ObjectUnsubscribedError = createErrorClass(function(_super) {
+    return function ObjectUnsubscribedErrorImpl() {
+        _super(this);
+        this.name = "ObjectUnsubscribedError";
+        this.message = "object unsubscribed";
+    };
+});
+
+var Subject = function(_super) {
+    __extends(Subject, _super);
+    function Subject() {
+        var _this = _super.call(this) || this;
+        _this.closed = false;
+        _this.currentObservers = null;
+        _this.observers = [];
+        _this.isStopped = false;
+        _this.hasError = false;
+        _this.thrownError = null;
+        return _this;
+    }
+    Subject.prototype.lift = function(operator) {
+        var subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+    };
+    Subject.prototype._throwIfClosed = function() {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+    };
+    Subject.prototype.next = function(value) {
+        var _this = this;
+        errorContext(function() {
+            var e_1, _a;
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                if (!_this.currentObservers) {
+                    _this.currentObservers = Array.from(_this.observers);
+                }
+                try {
+                    for(var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()){
+                        var observer = _c.value;
+                        observer.next(value);
+                    }
+                } catch (e_1_1) {
+                    e_1 = {
+                        error: e_1_1
+                    };
+                } finally{
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    } finally{
+                        if (e_1) throw e_1.error;
+                    }
+                }
+            }
+        });
+    };
+    Subject.prototype.error = function(err) {
+        var _this = this;
+        errorContext(function() {
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                _this.hasError = _this.isStopped = true;
+                _this.thrownError = err;
+                var observers = _this.observers;
+                while(observers.length){
+                    observers.shift().error(err);
+                }
+            }
+        });
+    };
+    Subject.prototype.complete = function() {
+        var _this = this;
+        errorContext(function() {
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                _this.isStopped = true;
+                var observers = _this.observers;
+                while(observers.length){
+                    observers.shift().complete();
+                }
+            }
+        });
+    };
+    Subject.prototype.unsubscribe = function() {
+        this.isStopped = this.closed = true;
+        this.observers = this.currentObservers = null;
+    };
+    Object.defineProperty(Subject.prototype, "observed", {
+        get: function get() {
+            var _a;
+            return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Subject.prototype._trySubscribe = function(subscriber) {
+        this._throwIfClosed();
+        return _super.prototype._trySubscribe.call(this, subscriber);
+    };
+    Subject.prototype._subscribe = function(subscriber) {
+        this._throwIfClosed();
+        this._checkFinalizedStatuses(subscriber);
+        return this._innerSubscribe(subscriber);
+    };
+    Subject.prototype._innerSubscribe = function(subscriber) {
+        var _this = this;
+        var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+        if (hasError || isStopped) {
+            return EMPTY_SUBSCRIPTION;
+        }
+        this.currentObservers = null;
+        observers.push(subscriber);
+        return new Subscription(function() {
+            _this.currentObservers = null;
+            arrRemove(observers, subscriber);
+        });
+    };
+    Subject.prototype._checkFinalizedStatuses = function(subscriber) {
+        var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+        if (hasError) {
+            subscriber.error(thrownError);
+        } else if (isStopped) {
+            subscriber.complete();
+        }
+    };
+    Subject.prototype.asObservable = function() {
+        var observable = new Observable();
+        observable.source = this;
+        return observable;
+    };
+    Subject.create = function(destination, source) {
+        return new AnonymousSubject(destination, source);
+    };
+    return Subject;
+}(Observable);
+var AnonymousSubject = function(_super) {
+    __extends(AnonymousSubject, _super);
+    function AnonymousSubject(destination, source) {
+        var _this = _super.call(this) || this;
+        _this.destination = destination;
+        _this.source = source;
+        return _this;
+    }
+    AnonymousSubject.prototype.next = function(value) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+    };
+    AnonymousSubject.prototype.error = function(err) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+    };
+    AnonymousSubject.prototype.complete = function() {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    AnonymousSubject.prototype._subscribe = function(subscriber) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+    };
+    return AnonymousSubject;
+}(Subject);
+
+function filter(predicate, thisArg) {
+    return operate(function(source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+            return predicate.call(thisArg, value, index++) && subscriber.next(value);
+        }));
+    });
+}
+
+// request-context.ts
+class RequestContext {
+    static currentRequestContext() {
+        const session = getRequestContext();
+        return session;
+    }
+    static currentRequest() {
+        const requestContext = RequestContext.currentRequestContext();
+        if (requestContext) {
+            return requestContext.request;
+        }
+        return null;
+    }
+    static currentTenantId() {
+        const user = RequestContext.currentUser();
+        if (user) {
+            return user.tenantId;
+        }
+        return null;
+    }
+    static currentUserId() {
+        const user = RequestContext.currentUser();
+        if (user) {
+            return user.id;
+        }
+        return null;
+    }
+    static currentRoleId() {
+        const user = RequestContext.currentUser();
+        if (user) {
+            return user.roleId;
+        }
+        return null;
+    }
+    static currentUser(throwError) {
+        const requestContext = RequestContext.currentRequestContext();
+        if (requestContext) {
+            // tslint:disable-next-line
+            const user = requestContext.request['user'];
+            if (user) {
+                return user;
+            }
+        }
+        if (throwError) {
+            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
+        }
+        return null;
+    }
+    static hasPermission(permission, throwError) {
+        return this.hasPermissions([
+            permission
+        ], throwError);
+    }
+    /**
+   * Retrieves the language code from the headers of the current request.
+   * @returns The language code (LanguagesEnum) extracted from the headers, or the default language (ENGLISH) if not found.
+   */ static getLanguageCode() {
+        // Retrieve the current request
+        const req = RequestContext.currentRequest();
+        // Variable to store the extracted language code
+        let lang;
+        // Check if a request exists
+        if (req) {
+            // Check if the 'language' header exists in the request
+            if (req.headers && req.headers['language']) {
+                // If found, set the lang variable
+                lang = req.headers['language'];
+            }
+        }
+        // Return the extracted language code or the default language (ENGLISH) if not found
+        return lang || contracts.LanguagesEnum.English;
+    }
+    static getOrganizationId() {
+        const req = this.currentRequest();
+        let organizationId;
+        const keys = [
+            'organization-id'
+        ];
+        if (req) {
+            for (const key of keys){
+                if (req.headers && req.headers[key]) {
+                    organizationId = req.headers[key];
+                    break;
+                }
+            }
+        }
+        return organizationId;
+    }
+    static hasPermissions(findPermissions, throwError) {
+        const requestContext = RequestContext.currentRequestContext();
+        if (requestContext) {
+            // tslint:disable-next-line
+            const token = passportJwt.ExtractJwt.fromAuthHeaderAsBearerToken()(requestContext.request);
+            if (token) {
+                const { permissions } = jsonwebtoken.verify(token, process.env['JWT_SECRET']);
+                if (permissions) {
+                    const found = permissions.filter((value)=>findPermissions.indexOf(value) >= 0);
+                    if (found.length === findPermissions.length) {
+                        return true;
+                    }
+                } else {
+                    return false;
+                }
+            }
+        }
+        if (throwError) {
+            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
+        }
+        return false;
+    }
+    static hasAnyPermission(findPermissions, throwError) {
+        const requestContext = RequestContext.currentRequestContext();
+        if (requestContext) {
+            // tslint:disable-next-line
+            const token = passportJwt.ExtractJwt.fromAuthHeaderAsBearerToken()(requestContext.request);
+            if (token) {
+                const { permissions } = jsonwebtoken.verify(token, process.env['JWT_SECRET']);
+                const found = permissions.filter((value)=>findPermissions.indexOf(value) >= 0);
+                if (found.length > 0) {
+                    return true;
+                }
+            }
+        }
+        if (throwError) {
+            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
+        }
+        return false;
+    }
+    static currentToken(throwError) {
+        const requestContext = RequestContext.currentRequestContext();
+        if (requestContext) {
+            // tslint:disable-next-line
+            return passportJwt.ExtractJwt.fromAuthHeaderAsBearerToken()(requestContext.request);
+        }
+        if (throwError) {
+            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
+        }
+        return null;
+    }
+    /**
+   * Checks if the current user has a specific role.
+   * @param {RolesEnum} role - The role to check.
+   * @param {boolean} throwError - Flag indicating whether to throw an error if the role is not granted.
+   * @returns {boolean} - True if the user has the role, otherwise false.
+   */ static hasRole(role, throwError) {
+        return this.hasRoles([
+            role
+        ], throwError);
+    }
+    /**
+   * Checks if the current request context has any of the specified roles.
+   *
+   * @param roles - An array of roles to check.
+   * @param throwError - Whether to throw an error if no roles are found.
+   * @returns True if any of the required roles are found, otherwise false.
+   */ static hasRoles(roles, throwError) {
+        const context = RequestContext.currentRequestContext();
+        if (context) {
+            try {
+                // tslint:disable-next-line
+                const token = this.currentToken();
+                if (token) {
+                    const { role } = jsonwebtoken.verify(token, process.env['JWT_SECRET']);
+                    return roles.includes(role != null ? role : null);
+                } else if (this.currentUser().role) {
+                    return roles.includes(this.currentUser().role.name);
+                }
+            } catch (error) {
+                if (error instanceof jsonwebtoken.JsonWebTokenError) {
+                    return false;
+                } else {
+                    throw error;
+                }
+            }
+        }
+        if (throwError) {
+            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
+        }
+        return false;
+    }
+    constructor(request, response, reqId, userId, extras = {}){
+        this.request = request;
+        this.response = response;
+        this.reqId = reqId;
+        this.userId = userId;
+        this.extras = extras;
+    }
+}
+const als = new node_async_hooks.AsyncLocalStorage();
+function getRequestContext() {
+    return als.getStore();
+}
+
+// request-context.middleware.ts
+exports.RequestContextMiddleware = class RequestContextMiddleware {
+    use(req, _res, next) {
+        var _req_user;
+        const reqId = req.headers['x-request-id'] || node_crypto.randomUUID();
+        // The userId can be placed in the authentication result here.
+        const userId = (_req_user = req['user']) == null ? void 0 : _req_user['id'];
+        const ctx = new RequestContext(req, _res, reqId, userId);
+        als.run(ctx, next);
+    }
+};
+exports.RequestContextMiddleware = __decorate([
+    common.Injectable()
+], exports.RequestContextMiddleware);
+function runWithRequestContext(req, res, next) {
+    var _req_user;
+    const reqId = req.headers['x-request-id'] || node_crypto.randomUUID();
+    const userId = (_req_user = req['user']) == null ? void 0 : _req_user['id'];
+    const ctx = new RequestContext(req, res, reqId, userId);
+    // Enable ALS scope
+    als.run(ctx, next);
+}
+
+exports.StrategyBus = class StrategyBus {
+    upsert(strategyType, entry) {
+        this.subject.next({
+            type: 'UPSERT',
+            strategyType,
+            entry
+        });
+    }
+    remove(orgId, pluginName) {
+        this.subject.next({
+            type: 'REMOVE',
+            orgId,
+            pluginName
+        });
+    }
+    constructor(){
+        this.subject = new Subject();
+        this.events$ = this.subject.asObservable();
+    }
+};
+exports.StrategyBus = __decorate([
+    common.Injectable()
+], exports.StrategyBus);
+
 class BaseStrategyRegistry {
     onModuleInit() {
+        this.bus.events$.pipe(filter((event)=>!event.strategyType || event.strategyType === this.strategyKey)).subscribe((evt)=>{
+            this.logger.debug(`Received strategy bus event: ${JSON.stringify(evt)}`);
+            if (evt.type === 'UPSERT') {
+                this.upsert(evt.entry.instance);
+            } else if (evt.type === 'REMOVE') {
+                this.remove(evt.orgId, evt.pluginName);
+            }
+        });
         const providers = this.discoveryService.getProviders();
         for (const wrapper of providers){
             const { instance } = wrapper;
             if (!instance) continue;
-            const type = this.reflector.get(this.strategyKey, instance.constructor);
-            if (type) {
-                this.strategies.set(type, instance);
+            this.upsert(instance);
+        }
+    }
+    upsert(instance) {
+        const type = this.reflector.get(this.strategyKey, instance.constructor);
+        if (type) {
+            var _instance_metatype;
+            const target = (_instance_metatype = instance.metatype) != null ? _instance_metatype : instance.constructor;
+            var _this_reflector_get;
+            const organizationId = (_this_reflector_get = this.reflector.get(ORGANIZATION_METADATA_KEY, target)) != null ? _this_reflector_get : GLOBAL_ORGANIZATION_SCOPE;
+            var _this_strategies_get;
+            const orgMap = (_this_strategies_get = this.strategies.get(organizationId)) != null ? _this_strategies_get : new Map();
+            orgMap.set(type, instance);
+            this.strategies.set(organizationId, orgMap);
+            const pluginName = this.reflector.get(PLUGIN_METADATA_KEY, target);
+            this.logger.debug(`Registered strategy of type ${type} for organization ${organizationId} from plugin ${pluginName}`);
+            if (pluginName) {
+                var _this_pluginStrategies_get;
+                const pluginStrategies = (_this_pluginStrategies_get = this.pluginStrategies.get(pluginName)) != null ? _this_pluginStrategies_get : new Set();
+                pluginStrategies.add(type);
+                this.pluginStrategies.set(pluginName, pluginStrategies);
             }
         }
     }
-    get(type) {
-        const strategy = this.strategies.get(type);
+    /**
+     * Remove all strategies registered by the given plugin for the given organization.
+     */ remove(organizationId, pluginName) {
+        const strategies = this.pluginStrategies.get(pluginName);
+        const orgMap = this.strategies.get(organizationId);
+        for (const type of strategies != null ? strategies : []){
+            orgMap == null ? void 0 : orgMap.delete(type);
+        }
+    }
+    /**
+     * Resolve organization id, falling back to request context org or global scope.
+     */ resolveOrganization(organizationId) {
+        var _ref;
+        return (_ref = organizationId != null ? organizationId : RequestContext.getOrganizationId()) != null ? _ref : GLOBAL_ORGANIZATION_SCOPE;
+    }
+    /**
+     * Get strategy by type from the given organization including global strategies as fallback.
+     * 
+     * @param type 
+     * @param organizationId 
+     * @returns 
+     */ get(type, organizationId) {
+        var _this_strategies_get, _this_strategies_get1;
+        organizationId != null ? organizationId : organizationId = RequestContext.getOrganizationId();
+        const orgKey = this.resolveOrganization(organizationId);
+        var _this_strategies_get_get;
+        const strategy = (_this_strategies_get_get = (_this_strategies_get = this.strategies.get(orgKey)) == null ? void 0 : _this_strategies_get.get(type)) != null ? _this_strategies_get_get : orgKey === GLOBAL_ORGANIZATION_SCOPE ? undefined : (_this_strategies_get1 = this.strategies.get(GLOBAL_ORGANIZATION_SCOPE)) == null ? void 0 : _this_strategies_get1.get(type);
         if (!strategy) {
             throw new Error(`No strategy found for type ${type}`);
         }
         return strategy;
     }
-    list() {
-        return Array.from(this.strategies.values());
+    /**
+     * List all strategies for the given organization including global strategies, or only global strategies if global org is specified.
+     * 
+     * @param organizationId 
+     * @returns 
+     */ list(organizationId) {
+        var _this_strategies_get, _this_strategies_get1;
+        organizationId != null ? organizationId : organizationId = RequestContext.getOrganizationId();
+        const orgKey = this.resolveOrganization(organizationId);
+        var _this_strategies_get_values;
+        const scoped = (_this_strategies_get_values = (_this_strategies_get = this.strategies.get(orgKey)) == null ? void 0 : _this_strategies_get.values()) != null ? _this_strategies_get_values : [];
+        var _this_strategies_get_values1;
+        const global = orgKey === GLOBAL_ORGANIZATION_SCOPE ? [] : (_this_strategies_get_values1 = (_this_strategies_get1 = this.strategies.get(GLOBAL_ORGANIZATION_SCOPE)) == null ? void 0 : _this_strategies_get1.values()) != null ? _this_strategies_get_values1 : [];
+        return Array.from(new Set([
+            ...scoped,
+            ...global
+        ]));
     }
     constructor(strategyKey, discoveryService, reflector){
         this.strategyKey = strategyKey;
         this.discoveryService = discoveryService;
         this.reflector = reflector;
+        this.logger = new common.Logger(BaseStrategyRegistry.name);
         this.strategies = new Map();
+        this.pluginStrategies = new Map();
     }
 }
+__decorate([
+    common.Inject(exports.StrategyBus),
+    __metadata("design:type", typeof exports.StrategyBus === "undefined" ? Object : exports.StrategyBus)
+], BaseStrategyRegistry.prototype, "bus", void 0);
 
 exports.IntegrationStrategyRegistry = class IntegrationStrategyRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -175,7 +1283,7 @@ exports.IntegrationStrategyRegistry = __decorate([
 ], exports.IntegrationStrategyRegistry);
 
 const WORKFLOW_TRIGGER_STRATEGY = 'WORKFLOW_TRIGGER_STRATEGY';
-const WorkflowTriggerStrategy = (provider)=>common.SetMetadata(WORKFLOW_TRIGGER_STRATEGY, provider);
+const WorkflowTriggerStrategy = (provider)=>common.applyDecorators(common.SetMetadata(WORKFLOW_TRIGGER_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, WORKFLOW_TRIGGER_STRATEGY));
 
 exports.WorkflowTriggerRegistry = class WorkflowTriggerRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -194,7 +1302,7 @@ exports.WorkflowTriggerRegistry = __decorate([
 const WORKFLOW_NODE_STRATEGY = 'WORKFLOW_NODE_STRATEGY';
 /**
  * Decorator to mark a provider as a Workflow Node Strategy
- */ const WorkflowNodeStrategy = (provider)=>common.SetMetadata(WORKFLOW_NODE_STRATEGY, provider);
+ */ const WorkflowNodeStrategy = (provider)=>common.applyDecorators(common.SetMetadata(WORKFLOW_NODE_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, WORKFLOW_NODE_STRATEGY));
 
 exports.WorkflowNodeRegistry = class WorkflowNodeRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -210,8 +1318,19 @@ exports.WorkflowNodeRegistry = __decorate([
     ])
 ], exports.WorkflowNodeRegistry);
 
+/**
+ * Wrap Workflow Node Execution Command
+ */ class WrapWorkflowNodeExecutionCommand extends cqrs.Command {
+    constructor(fuc, params){
+        super();
+        this.fuc = fuc;
+        this.params = params;
+    }
+}
+WrapWorkflowNodeExecutionCommand.type = '[Workflow] Wrap Workflow Node Execution';
+
 const VECTOR_STORE_STRATEGY = 'VECTOR_STORE_STRATEGY';
-const VectorStoreStrategy = (provider)=>common.SetMetadata(VECTOR_STORE_STRATEGY, provider);
+const VectorStoreStrategy = (provider)=>common.applyDecorators(common.SetMetadata(VECTOR_STORE_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, VECTOR_STORE_STRATEGY));
 
 exports.VectorStoreRegistry = class VectorStoreRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -228,7 +1347,7 @@ exports.VectorStoreRegistry = __decorate([
 ], exports.VectorStoreRegistry);
 
 const TEXT_SPLITTER_STRATEGY = 'TEXT_SPLITTER_STRATEGY';
-const TextSplitterStrategy = (provider)=>common.SetMetadata(TEXT_SPLITTER_STRATEGY, provider);
+const TextSplitterStrategy = (provider)=>common.applyDecorators(common.SetMetadata(TEXT_SPLITTER_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, TEXT_SPLITTER_STRATEGY));
 
 exports.TextSplitterRegistry = class TextSplitterRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -247,7 +1366,7 @@ exports.TextSplitterRegistry = __decorate([
 const DOCUMENT_SOURCE_STRATEGY = 'DOCUMENT_SOURCE_STRATEGY';
 /**
  * Decorator to mark a provider as a Document Source Strategy
- */ const DocumentSourceStrategy = (provider)=>common.SetMetadata(DOCUMENT_SOURCE_STRATEGY, provider);
+ */ const DocumentSourceStrategy = (provider)=>common.applyDecorators(common.SetMetadata(DOCUMENT_SOURCE_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, DOCUMENT_SOURCE_STRATEGY));
 
 exports.DocumentSourceRegistry = class DocumentSourceRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -266,7 +1385,7 @@ exports.DocumentSourceRegistry = __decorate([
 const DOCUMENT_TRANSFORMER_STRATEGY = 'DOCUMENT_TRANSFORMER_STRATEGY';
 /**
  * Decorator to mark a provider as a Document Transformer Strategy
- */ const DocumentTransformerStrategy = (provider)=>common.SetMetadata(DOCUMENT_TRANSFORMER_STRATEGY, provider);
+ */ const DocumentTransformerStrategy = (provider)=>common.applyDecorators(common.SetMetadata(DOCUMENT_TRANSFORMER_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, DOCUMENT_TRANSFORMER_STRATEGY));
 
 exports.DocumentTransformerRegistry = class DocumentTransformerRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -285,7 +1404,7 @@ exports.DocumentTransformerRegistry = __decorate([
 const RETRIEVER_STRATEGY = 'RETRIEVER_STRATEGY';
 /**
  * Decorator to mark a provider as a Retriever Strategy
- */ const RetrieverStrategy = (provider)=>common.SetMetadata(RETRIEVER_STRATEGY, provider);
+ */ const RetrieverStrategy = (provider)=>common.applyDecorators(common.SetMetadata(RETRIEVER_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, RETRIEVER_STRATEGY));
 
 exports.RetrieverRegistry = class RetrieverRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -360,7 +1479,7 @@ async function downloadRemoteFile(url, dest) {
 const IMAGE_UNDERSTANDING_STRATEGY = 'IMAGE_UNDERSTANDING_STRATEGY';
 /**
  * Decorator to mark a provider as an Image Understanding Strategy
- */ const ImageUnderstandingStrategy = (provider)=>common.SetMetadata(IMAGE_UNDERSTANDING_STRATEGY, provider);
+ */ const ImageUnderstandingStrategy = (provider)=>common.applyDecorators(common.SetMetadata(IMAGE_UNDERSTANDING_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, IMAGE_UNDERSTANDING_STRATEGY));
 
 exports.ImageUnderstandingRegistry = class ImageUnderstandingRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -377,7 +1496,7 @@ exports.ImageUnderstandingRegistry = __decorate([
 ], exports.ImageUnderstandingRegistry);
 
 const KNOWLEDGE_STRATEGY = 'KNOWLEDGE_STRATEGY';
-const KnowledgeStrategyKey = (provider)=>common.SetMetadata(KNOWLEDGE_STRATEGY, provider);
+const KnowledgeStrategyKey = (provider)=>common.applyDecorators(common.SetMetadata(KNOWLEDGE_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, KNOWLEDGE_STRATEGY));
 
 exports.KnowledgeStrategyRegistry = class KnowledgeStrategyRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -396,7 +1515,7 @@ exports.KnowledgeStrategyRegistry = __decorate([
 const TOOLSET_STRATEGY = 'TOOLSET_STRATEGY';
 /**
  * Decorator to mark a provider as a Toolset Strategy
- */ const ToolsetStrategy = (provider)=>common.SetMetadata(TOOLSET_STRATEGY, provider);
+ */ const ToolsetStrategy = (provider)=>common.applyDecorators(common.SetMetadata(TOOLSET_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, TOOLSET_STRATEGY));
 
 exports.ToolsetRegistry = class ToolsetRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -700,224 +1819,8 @@ function getErrorMessage(err) {
     return error;
 }
 
-// request-context.ts
-class RequestContext {
-    static currentRequestContext() {
-        const session = getRequestContext();
-        return session;
-    }
-    static currentRequest() {
-        const requestContext = RequestContext.currentRequestContext();
-        if (requestContext) {
-            return requestContext.request;
-        }
-        return null;
-    }
-    static currentTenantId() {
-        const user = RequestContext.currentUser();
-        if (user) {
-            return user.tenantId;
-        }
-        return null;
-    }
-    static currentUserId() {
-        const user = RequestContext.currentUser();
-        if (user) {
-            return user.id;
-        }
-        return null;
-    }
-    static currentRoleId() {
-        const user = RequestContext.currentUser();
-        if (user) {
-            return user.roleId;
-        }
-        return null;
-    }
-    static currentUser(throwError) {
-        const requestContext = RequestContext.currentRequestContext();
-        if (requestContext) {
-            // tslint:disable-next-line
-            const user = requestContext.request['user'];
-            if (user) {
-                return user;
-            }
-        }
-        if (throwError) {
-            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
-        }
-        return null;
-    }
-    static hasPermission(permission, throwError) {
-        return this.hasPermissions([
-            permission
-        ], throwError);
-    }
-    /**
-   * Retrieves the language code from the headers of the current request.
-   * @returns The language code (LanguagesEnum) extracted from the headers, or the default language (ENGLISH) if not found.
-   */ static getLanguageCode() {
-        // Retrieve the current request
-        const req = RequestContext.currentRequest();
-        // Variable to store the extracted language code
-        let lang;
-        // Check if a request exists
-        if (req) {
-            // Check if the 'language' header exists in the request
-            if (req.headers && req.headers['language']) {
-                // If found, set the lang variable
-                lang = req.headers['language'];
-            }
-        }
-        // Return the extracted language code or the default language (ENGLISH) if not found
-        return lang || contracts.LanguagesEnum.English;
-    }
-    static getOrganizationId() {
-        const req = this.currentRequest();
-        let organizationId;
-        const keys = [
-            'organization-id'
-        ];
-        if (req) {
-            for (const key of keys){
-                if (req.headers && req.headers[key]) {
-                    organizationId = req.headers[key];
-                    break;
-                }
-            }
-        }
-        return organizationId;
-    }
-    static hasPermissions(findPermissions, throwError) {
-        const requestContext = RequestContext.currentRequestContext();
-        if (requestContext) {
-            // tslint:disable-next-line
-            const token = passportJwt.ExtractJwt.fromAuthHeaderAsBearerToken()(requestContext.request);
-            if (token) {
-                const { permissions } = jsonwebtoken.verify(token, process.env['JWT_SECRET']);
-                if (permissions) {
-                    const found = permissions.filter((value)=>findPermissions.indexOf(value) >= 0);
-                    if (found.length === findPermissions.length) {
-                        return true;
-                    }
-                } else {
-                    return false;
-                }
-            }
-        }
-        if (throwError) {
-            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
-        }
-        return false;
-    }
-    static hasAnyPermission(findPermissions, throwError) {
-        const requestContext = RequestContext.currentRequestContext();
-        if (requestContext) {
-            // tslint:disable-next-line
-            const token = passportJwt.ExtractJwt.fromAuthHeaderAsBearerToken()(requestContext.request);
-            if (token) {
-                const { permissions } = jsonwebtoken.verify(token, process.env['JWT_SECRET']);
-                const found = permissions.filter((value)=>findPermissions.indexOf(value) >= 0);
-                if (found.length > 0) {
-                    return true;
-                }
-            }
-        }
-        if (throwError) {
-            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
-        }
-        return false;
-    }
-    static currentToken(throwError) {
-        const requestContext = RequestContext.currentRequestContext();
-        if (requestContext) {
-            // tslint:disable-next-line
-            return passportJwt.ExtractJwt.fromAuthHeaderAsBearerToken()(requestContext.request);
-        }
-        if (throwError) {
-            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
-        }
-        return null;
-    }
-    /**
-   * Checks if the current user has a specific role.
-   * @param {RolesEnum} role - The role to check.
-   * @param {boolean} throwError - Flag indicating whether to throw an error if the role is not granted.
-   * @returns {boolean} - True if the user has the role, otherwise false.
-   */ static hasRole(role, throwError) {
-        return this.hasRoles([
-            role
-        ], throwError);
-    }
-    /**
-   * Checks if the current request context has any of the specified roles.
-   *
-   * @param roles - An array of roles to check.
-   * @param throwError - Whether to throw an error if no roles are found.
-   * @returns True if any of the required roles are found, otherwise false.
-   */ static hasRoles(roles, throwError) {
-        const context = RequestContext.currentRequestContext();
-        if (context) {
-            try {
-                // tslint:disable-next-line
-                const token = this.currentToken();
-                if (token) {
-                    const { role } = jsonwebtoken.verify(token, process.env['JWT_SECRET']);
-                    return roles.includes(role != null ? role : null);
-                } else if (this.currentUser().role) {
-                    return roles.includes(this.currentUser().role.name);
-                }
-            } catch (error) {
-                if (error instanceof jsonwebtoken.JsonWebTokenError) {
-                    return false;
-                } else {
-                    throw error;
-                }
-            }
-        }
-        if (throwError) {
-            throw new common.HttpException('Unauthorized', common.HttpStatus.UNAUTHORIZED);
-        }
-        return false;
-    }
-    constructor(request, response, reqId, userId, extras = {}){
-        this.request = request;
-        this.response = response;
-        this.reqId = reqId;
-        this.userId = userId;
-        this.extras = extras;
-    }
-}
-const als = new node_async_hooks.AsyncLocalStorage();
-function getRequestContext() {
-    return als.getStore();
-}
-
-// request-context.middleware.ts
-exports.RequestContextMiddleware = class RequestContextMiddleware {
-    use(req, _res, next) {
-        var _req_user;
-        const reqId = req.headers['x-request-id'] || node_crypto.randomUUID();
-        // The userId can be placed in the authentication result here.
-        const userId = (_req_user = req['user']) == null ? void 0 : _req_user['id'];
-        const ctx = new RequestContext(req, _res, reqId, userId);
-        als.run(ctx, next);
-    }
-};
-exports.RequestContextMiddleware = __decorate([
-    common.Injectable()
-], exports.RequestContextMiddleware);
-function runWithRequestContext(req, res, next) {
-    var _req_user;
-    const reqId = req.headers['x-request-id'] || node_crypto.randomUUID();
-    const userId = (_req_user = req['user']) == null ? void 0 : _req_user['id'];
-    const ctx = new RequestContext(req, res, reqId, userId);
-    // Enable ALS scope
-    als.run(ctx, next);
-}
-
 const DATASOURCE_STRATEGY = 'DATASOURCE_STRATEGY';
-const DataSourceStrategy = (provider)=>common.SetMetadata(DATASOURCE_STRATEGY, provider);
+const DataSourceStrategy = (provider)=>common.applyDecorators(common.SetMetadata(DATASOURCE_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, DATASOURCE_STRATEGY));
 
 exports.DataSourceStrategyRegistry = class DataSourceStrategyRegistry extends BaseStrategyRegistry {
     constructor(discoveryService, reflector){
@@ -1080,6 +1983,93 @@ class BaseSQLQueryRunner extends BaseQueryRunner {
     async ping() {
         await this.runQuery(`SELECT 1`);
     }
+    /**
+   * Default implementation for table operations
+   */ async tableOp(action, params, options) {
+        switch(action){
+            case "createTable":
+                {
+                    // Default implementation for creating table (generic SQL syntax)
+                    const { schema, table, columns, createMode = "error" } = params;
+                    const tableName = schema ? `${schema}.${table}` : table;
+                    // Check if table exists (try to query table info)
+                    let exists = false;
+                    try {
+                        const result = await this.runQuery(`SELECT * FROM ${tableName} WHERE 1=0`, options);
+                        exists = true;
+                    } catch (error) {
+                        // Table does not exist
+                        exists = false;
+                    }
+                    // --- MODE: ERROR → throw error if table exists ---
+                    if (exists && createMode === "error") {
+                        throw new Error(`Table "${tableName}" already exists`);
+                    }
+                    // --- MODE: IGNORE → do nothing if exists ---
+                    if (exists && createMode === "ignore") {
+                        return;
+                    }
+                    // --- MODE: UPGRADE → auto upgrade (simple implementation: only add new columns) ---
+                    // Note: This default implementation does not support modifying column types, 
+                    //       recommend each database to implement its own version
+                    if (exists && createMode === "upgrade") {
+                        console.warn(`[BaseSQLQueryRunner] UPGRADE mode uses basic implementation. Consider implementing tableOp for better support.`);
+                        // Try to add new columns (will fail if column already exists, but doesn't affect)
+                        for (const col of columns){
+                            try {
+                                const colType = this.mapColumnType(col.type, col.isKey, col.length);
+                                await this.runQuery(`ALTER TABLE ${tableName} ADD COLUMN ${col.fieldName} ${colType}`, options);
+                            } catch (error) {
+                                // Field might already exist, ignore error
+                                console.debug(`Failed to add column ${col.fieldName}:`, error instanceof Error ? error.message : String(error));
+                            }
+                        }
+                        return;
+                    }
+                    // --- MODE: CREATE NEW TABLE ---
+                    const columnsDDL = columns.map((col)=>{
+                        const colType = this.mapColumnType(col.type, col.isKey, col.length);
+                        const pk = col.isKey ? ' PRIMARY KEY' : '';
+                        const notNull = col.required ? ' NOT NULL' : '';
+                        return `${col.fieldName} ${colType}${pk}${notNull}`;
+                    }).join(', ');
+                    const createTableStatement = `CREATE TABLE ${tableName} (${columnsDDL})`;
+                    await this.runQuery(createTableStatement, options);
+                    return;
+                }
+            case "dropTable":
+                {
+                    // Default implementation for dropping table
+                    const { schema, table } = params;
+                    const tableName = schema ? `${schema}.${table}` : table;
+                    await this.runQuery(`DROP TABLE IF EXISTS ${tableName}`, options);
+                    return;
+                }
+            default:
+                // Throw error for other unimplemented operations
+                throw new Error(`Unsupported table action: ${action}`);
+        }
+    }
+    /**
+   * Generic type mapping (subclasses can override)
+   */ mapColumnType(type, isKey, length) {
+        switch(type == null ? void 0 : type.toLowerCase()){
+            case 'string':
+                return length ? `VARCHAR(${length})` : isKey ? 'VARCHAR(255)' : 'VARCHAR(1000)';
+            case 'number':
+                return 'INT';
+            case 'boolean':
+                return 'BOOLEAN';
+            case 'date':
+                return 'DATE';
+            case 'datetime':
+                return 'TIMESTAMP';
+            case 'object':
+                return 'TEXT';
+            default:
+                return 'VARCHAR(1000)';
+        }
+    }
     constructor(...args){
         super(...args);
         this.syntax = "sql";
@@ -1143,6 +2133,7 @@ function AIModelProviderStrategy(provider) {
     }
     const dir = file ? path.dirname(file) : process.cwd();
     return function(target) {
+        common.SetMetadata(STRATEGY_META_KEY, AI_MODEL_PROVIDER)(target);
         // Ensure NestJS is discoverable
         common.SetMetadata(AI_MODEL_PROVIDER, provider)(target);
         // Write custom path (does not affect Discovery)
@@ -2049,6 +3040,42 @@ class Speech2TextChatModel extends chat_models.BaseChatModel {
     return 0;
 }
 
+/**
+ * Get a Chat Model of copilot model and check it's token limitation, record the token usage
+ */ class CreateModelClientCommand extends cqrs.Command {
+    constructor(copilotModel, options){
+        super();
+        this.copilotModel = copilotModel;
+        this.options = options;
+    }
+}
+CreateModelClientCommand.type = '[AI Model] Create Model Client';
+
+const AGENT_MIDDLEWARE_STRATEGY = 'AGENT_MIDDLEWARE_STRATEGY';
+const AgentMiddlewareStrategy = (provider)=>common.applyDecorators(common.SetMetadata(AGENT_MIDDLEWARE_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, AGENT_MIDDLEWARE_STRATEGY));
+
+exports.AgentMiddlewareRegistry = class AgentMiddlewareRegistry extends BaseStrategyRegistry {
+    constructor(discoveryService, reflector){
+        super(AGENT_MIDDLEWARE_STRATEGY, discoveryService, reflector);
+    }
+};
+exports.AgentMiddlewareRegistry = __decorate([
+    common.Injectable(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [
+        typeof core.DiscoveryService === "undefined" ? Object : core.DiscoveryService,
+        typeof core.Reflector === "undefined" ? Object : core.Reflector
+    ])
+], exports.AgentMiddlewareRegistry);
+
+/**
+ * jump targets (user facing)
+ */ const JUMP_TO_TARGETS = [
+    "model",
+    "tools",
+    "end"
+];
+
 Object.defineProperty(exports, "IColumnDef", {
 	enumerable: true,
 	get: function () { return contracts.IColumnDef; }
@@ -2065,19 +3092,23 @@ Object.defineProperty(exports, "TDocumentAsset", {
 	enumerable: true,
 	get: function () { return contracts.TDocumentAsset; }
 });
+exports.AGENT_MIDDLEWARE_STRATEGY = AGENT_MIDDLEWARE_STRATEGY;
 exports.AIModelProviderNotFoundException = AIModelProviderNotFoundException;
 exports.AIModelProviderStrategy = AIModelProviderStrategy;
 exports.AI_MODEL_PROVIDER = AI_MODEL_PROVIDER;
 exports.AdapterDataSourceStrategy = AdapterDataSourceStrategy;
+exports.AgentMiddlewareStrategy = AgentMiddlewareStrategy;
 exports.AiModelNotFoundException = AiModelNotFoundException;
 exports.BaseHTTPQueryRunner = BaseHTTPQueryRunner;
 exports.BaseQueryRunner = BaseQueryRunner;
 exports.BaseSQLQueryRunner = BaseSQLQueryRunner;
+exports.BaseStrategyRegistry = BaseStrategyRegistry;
 exports.BaseTool = BaseTool;
 exports.BaseToolset = BaseToolset;
 exports.BuiltinToolset = BuiltinToolset;
 exports.ChatOAICompatReasoningModel = ChatOAICompatReasoningModel;
 exports.CommonParameterRules = CommonParameterRules;
+exports.CreateModelClientCommand = CreateModelClientCommand;
 exports.CredentialsValidateFailedError = CredentialsValidateFailedError;
 exports.DATASOURCE_STRATEGY = DATASOURCE_STRATEGY;
 exports.DOCUMENT_SOURCE_STRATEGY = DOCUMENT_SOURCE_STRATEGY;
@@ -2085,16 +3116,20 @@ exports.DOCUMENT_TRANSFORMER_STRATEGY = DOCUMENT_TRANSFORMER_STRATEGY;
 exports.DataSourceStrategy = DataSourceStrategy;
 exports.DocumentSourceStrategy = DocumentSourceStrategy;
 exports.DocumentTransformerStrategy = DocumentTransformerStrategy;
+exports.GLOBAL_ORGANIZATION_SCOPE = GLOBAL_ORGANIZATION_SCOPE;
 exports.IMAGE_UNDERSTANDING_STRATEGY = IMAGE_UNDERSTANDING_STRATEGY;
 exports.INTEGRATION_STRATEGY = INTEGRATION_STRATEGY;
 exports.ImageUnderstandingStrategy = ImageUnderstandingStrategy;
 exports.IntegrationStrategyKey = IntegrationStrategyKey;
+exports.JUMP_TO_TARGETS = JUMP_TO_TARGETS;
 exports.KNOWLEDGE_STRATEGY = KNOWLEDGE_STRATEGY;
 exports.KnowledgeStrategyKey = KnowledgeStrategyKey;
 exports.LLMUsage = LLMUsage;
 exports.LargeLanguageModel = LargeLanguageModel;
+exports.ORGANIZATION_METADATA_KEY = ORGANIZATION_METADATA_KEY;
 exports.OpenAICompatibleReranker = OpenAICompatibleReranker;
 exports.PLUGIN_METADATA = PLUGIN_METADATA;
+exports.PLUGIN_METADATA_KEY = PLUGIN_METADATA_KEY;
 exports.PROVIDE_AI_MODEL_LLM = PROVIDE_AI_MODEL_LLM;
 exports.PROVIDE_AI_MODEL_MODERATION = PROVIDE_AI_MODEL_MODERATION;
 exports.PROVIDE_AI_MODEL_RERANK = PROVIDE_AI_MODEL_RERANK;
@@ -2105,6 +3140,7 @@ exports.RETRIEVER_STRATEGY = RETRIEVER_STRATEGY;
 exports.RequestContext = RequestContext;
 exports.RerankModel = RerankModel;
 exports.RetrieverStrategy = RetrieverStrategy;
+exports.STRATEGY_META_KEY = STRATEGY_META_KEY;
 exports.Speech2TextChatModel = Speech2TextChatModel;
 exports.SpeechToTextModel = SpeechToTextModel;
 exports.TEXT_SPLITTER_STRATEGY = TEXT_SPLITTER_STRATEGY;
@@ -2119,6 +3155,7 @@ exports.WORKFLOW_NODE_STRATEGY = WORKFLOW_NODE_STRATEGY;
 exports.WORKFLOW_TRIGGER_STRATEGY = WORKFLOW_TRIGGER_STRATEGY;
 exports.WorkflowNodeStrategy = WorkflowNodeStrategy;
 exports.WorkflowTriggerStrategy = WorkflowTriggerStrategy;
+exports.WrapWorkflowNodeExecutionCommand = WrapWorkflowNodeExecutionCommand;
 exports.XpFileSystem = XpFileSystem;
 exports.XpertServerPlugin = XpertServerPlugin;
 exports.als = als;