@jterrazz/intelligence 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1461 @@
+'use strict';
+
+var prompts = require('@langchain/core/prompts');
+var agents = require('langchain/agents');
+var v4 = require('zod/v4');
+var openai = require('@langchain/openai');
+var tools = require('langchain/tools');
+
+/**
+ * Custom error for AI response parsing failures
+ */ function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$6(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _define_property$6(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of$2(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var AIResponseParserError = /*#__PURE__*/ function(Error1) {
+    _inherits(AIResponseParserError, Error1);
+    function AIResponseParserError(message, cause, text) {
+        _class_call_check$6(this, AIResponseParserError);
+        var _this;
+        _this = _call_super(this, AIResponseParserError, [
+            message
+        ]), _define_property$6(_this, "cause", void 0), _define_property$6(_this, "text", void 0), _this.cause = cause, _this.text = text;
+        _this.name = 'AIResponseParserError';
+        return _this;
+    }
+    return AIResponseParserError;
+}(_wrap_native_super(Error));
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check$5(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$5(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$5(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof$2(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * Parses AI response text into structured data based on Zod schema
+ */ var AIResponseParser = /*#__PURE__*/ function() {
+    function AIResponseParser(schema) {
+        _class_call_check$5(this, AIResponseParser);
+        _define_property$5(this, "schema", void 0);
+        this.schema = schema;
+    }
+    _create_class$5(AIResponseParser, [
+        {
+            key: "parse",
+            value: /**
+     * Parses the AI response text based on the configured schema
+     */ function parse(text) {
+                try {
+                    var cleanedText = this.cleanText(text);
+                    var json = this.extractJsonFromText(cleanedText);
+                    var unescapedJson = this.unescapeJsonValues(json);
+                    return this.schema.parse(unescapedJson);
+                } catch (error) {
+                    if (_instanceof$2(error, v4.z.ZodError)) {
+                        throw new AIResponseParserError('Failed to validate response against schema', error, text);
+                    }
+                    throw error;
+                }
+            }
+        },
+        {
+            key: "cleanText",
+            value: /**
+     * Cleans text and finds the largest schema-compatible structure
+     */ function cleanText(text) {
+                var _this = this;
+                // First try to extract from markdown code blocks
+                var codeBlocks = text.match(/```(?:json)?\r?\n([^`]*?)\r?\n```/g);
+                if (codeBlocks) {
+                    // Try each code block and return the largest valid one
+                    var validBlocks = codeBlocks.map(function(block) {
+                        return _this.extractJsonFromCodeBlock(block);
+                    }).filter(function(block) {
+                        return block !== null;
+                    });
+                    if (validBlocks.length > 0) {
+                        return this.findLargestString(validBlocks);
+                    }
+                }
+                // If no valid code blocks, try to find JSON-like structures in the text
+                var jsonMatches = this.findJsonStructures(text);
+                if (jsonMatches.length > 0) {
+                    return this.findLargestString(jsonMatches);
+                }
+                // If no JSON structures found, clean and return the original text
+                return text.replace(/\s+/g, ' ').trim();
+            }
+        },
+        {
+            key: "convertToPrimitive",
+            value: /**
+     * Converts value to appropriate primitive type based on schema
+     */ function convertToPrimitive(value, schema) {
+                if (_instanceof$2(schema, v4.z.ZodString)) {
+                    return String(value);
+                }
+                if (_instanceof$2(schema, v4.z.ZodNumber)) {
+                    return Number(value);
+                }
+                if (_instanceof$2(schema, v4.z.ZodBoolean)) {
+                    return Boolean(value);
+                }
+                if (_instanceof$2(schema, v4.z.ZodNull)) {
+                    return null;
+                }
+                return value;
+            }
+        },
+        {
+            key: "extractArray",
+            value: /**
+     * Extracts array from text
+     */ function extractArray(text) {
+                var arrayStart = text.indexOf('[');
+                var arrayEnd = text.lastIndexOf(']');
+                if (arrayStart === -1 || arrayEnd === -1) {
+                    throw new AIResponseParserError('No array found in response', undefined, text);
+                }
+                try {
+                    return JSON.parse(text.slice(arrayStart, arrayEnd + 1));
+                } catch (error) {
+                    throw new AIResponseParserError('Failed to parse array JSON', error, text);
+                }
+            }
+        },
+        {
+            key: "extractJsonFromCodeBlock",
+            value: /**
+     * Extracts and validates JSON content from a code block
+     */ function extractJsonFromCodeBlock(block) {
+                var content = block.replace(/```(?:json)?\r?\n([^`]*?)\r?\n```/, '$1').trim();
+                try {
+                    // Attempt to parse as JSON to validate structure
+                    JSON.parse(content);
+                    return content;
+                } catch (e) {
+                    return null;
+                }
+            }
+        },
+        {
+            key: "extractJsonFromText",
+            value: /**
+     * Extracts and parses JSON from text based on schema type
+     */ function extractJsonFromText(text) {
+                if (_instanceof$2(this.schema, v4.z.ZodArray)) {
+                    return this.extractArray(text);
+                }
+                if (_instanceof$2(this.schema, v4.z.ZodObject)) {
+                    return this.extractObject(text);
+                }
+                if (_instanceof$2(this.schema, v4.z.ZodString) || _instanceof$2(this.schema, v4.z.ZodNumber) || _instanceof$2(this.schema, v4.z.ZodBoolean) || _instanceof$2(this.schema, v4.z.ZodNull)) {
+                    return this.extractPrimitive(text, this.schema);
+                }
+                throw new AIResponseParserError('Unsupported schema type', undefined, text);
+            }
+        },
+        {
+            key: "extractObject",
+            value: /**
+     * Extracts object from text
+     */ function extractObject(text) {
+                var objectStart = text.indexOf('{');
+                var objectEnd = text.lastIndexOf('}');
+                if (objectStart === -1 || objectEnd === -1) {
+                    throw new AIResponseParserError('No object found in response', undefined, text);
+                }
+                try {
+                    return JSON.parse(text.slice(objectStart, objectEnd + 1));
+                } catch (error) {
+                    throw new AIResponseParserError('Failed to parse object JSON', error, text);
+                }
+            }
+        },
+        {
+            key: "extractPrimitive",
+            value: /**
+     * Extracts and converts primitive value from text
+     */ function extractPrimitive(text, schema) {
+                var trimmed = text.trim();
+                // Try to parse as JSON first in case it's quoted
+                try {
+                    var parsed = JSON.parse(trimmed);
+                    return this.convertToPrimitive(parsed, schema);
+                } catch (e) {
+                    // If not valid JSON, use the raw string
+                    return this.convertToPrimitive(trimmed, schema);
+                }
+            }
+        },
+        {
+            key: "findJsonStructures",
+            value: /**
+     * Finds valid JSON structures in raw text
+     */ function findJsonStructures(text) {
+                var jsonMatches = [];
+                var depth = 0;
+                var start = -1;
+                for(var i = 0; i < text.length; i++){
+                    var char = text[i];
+                    if (char === '{' || char === '[') {
+                        if (depth === 0) start = i;
+                        depth++;
+                    } else if (char === '}' || char === ']') {
+                        depth--;
+                        if (depth === 0 && start !== -1) {
+                            var potentialJson = text.slice(start, i + 1);
+                            try {
+                                JSON.parse(potentialJson);
+                                jsonMatches.push(potentialJson);
+                            } catch (e) {
+                            // Invalid JSON, ignore
+                            }
+                        }
+                    }
+                }
+                return jsonMatches;
+            }
+        },
+        {
+            key: "findLargestString",
+            value: /**
+     * Returns the largest string from an array of strings
+     */ function findLargestString(strings) {
+                return strings.reduce(function(largest, current) {
+                    return current.length > largest.length ? current : largest;
+                }, strings[0]);
+            }
+        },
+        {
+            key: "unescapeJsonValues",
+            value: /**
+     * Recursively unescapes all string values in a JSON object/array
+     */ function unescapeJsonValues(json) {
+                var _this = this;
+                if (typeof json === 'string') {
+                    return this.unescapeText(json);
+                }
+                if (Array.isArray(json)) {
+                    return json.map(function(item) {
+                        return _this.unescapeJsonValues(item);
+                    });
+                }
+                if ((typeof json === "undefined" ? "undefined" : _type_of$1(json)) === 'object' && json !== null) {
+                    return Object.fromEntries(Object.entries(json).map(function(param) {
+                        var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                        return [
+                            key,
+                            _this.unescapeJsonValues(value)
+                        ];
+                    }));
+                }
+                return json;
+            }
+        },
+        {
+            key: "unescapeText",
+            value: /**
+     * Unescapes common escaped characters in text
+     */ function unescapeText(text) {
+                return text.replace(/\\"/g, '"') // Unescape quotes
+                .replace(/\\n/g, '\n') // Unescape newlines
+                .replace(/\\r/g, '\r') // Unescape carriage returns
+                .replace(/\\t/g, '\t') // Unescape tabs
+                .replace(/\\\\/g, '\\') // Unescape backslashes
+                .replace(/\\u([0-9a-fA-F]{4})/g, function(_, code) {
+                    return String.fromCharCode(parseInt(code, 16));
+                }); // Unescape unicode
+            }
+        }
+    ]);
+    return AIResponseParser;
+}();
+
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$4(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$4(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$4(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$4(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, 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
+        };
+    }
+}
+// Schema for agent responses
+var AgentResponseSchema = v4.z.object({
+    message: v4.z.string().optional(),
+    reason: v4.z.string().optional(),
+    shouldRespond: v4.z["boolean"]()
+});
+// LangChain-specific framework rules (internal to this adapter)
+var LANGCHAIN_FRAMEWORK_RULES = '\n<AGENT_FRAMEWORK>\nYou are a chat agent piloted by the LangChain framework.\n\nYou have access to the following tools: {tools}\nTool names: {tool_names}\nAgent scratchpad: {agent_scratchpad}\n\nWhen you want to provide your final response, you MUST format it exactly like this:\n\n```json\n{{"action": "Final Answer", "action_input": {{"shouldRespond": false, "reason": "<your reason>"}}}}\n```\n\nOR \n\n```json\n{{"action": "Final Answer", "action_input": {{"shouldRespond": true, "message": "<your response message>"}}}}\n```\n\n"shouldRespond" set to true means the message will be sent to the user.\n"shouldRespond" set to false means the message will not be sent to the user.\n\nALWAYS use this exact format with markdown code blocks and the action/action_input structure.\n</AGENT_FRAMEWORK>';
+/**
+ * Chat agent adapter that provides structured chat capabilities with optional responses
+ */ var ChatAgentAdapter = /*#__PURE__*/ function() {
+    function ChatAgentAdapter(name, systemPrompt, options) {
+        _class_call_check$4(this, ChatAgentAdapter);
+        _define_property$4(this, "executorPromise", void 0);
+        _define_property$4(this, "logger", void 0);
+        _define_property$4(this, "name", void 0);
+        _define_property$4(this, "responseParser", void 0);
+        this.name = name;
+        this.logger = options.logger;
+        this.responseParser = new AIResponseParser(AgentResponseSchema);
+        this.executorPromise = this.createExecutor(systemPrompt, options);
+    }
+    _create_class$4(ChatAgentAdapter, [
+        {
+            key: "run",
+            value: function run(userPrompt) {
+                return _async_to_generator$1(function() {
+                    var _this_logger, executor, input, result, response, error, _this_logger1;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    this.executorPromise
+                                ];
+                            case 1:
+                                executor = _state.sent();
+                                input = this.resolveUserInput(userPrompt);
+                                return [
+                                    4,
+                                    executor.invoke({
+                                        input: input
+                                    })
+                                ];
+                            case 2:
+                                result = _state.sent();
+                                (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : _this_logger.debug('Agent execution result', {
+                                    agentName: this.name,
+                                    hasOutput: 'output' in result,
+                                    hasUserPrompt: !!userPrompt,
+                                    outputType: _type_of(result.output)
+                                });
+                                if (!result || typeof result.output === 'undefined') {
+                                    throw new Error('Agent returned invalid result structure');
+                                }
+                                response = this.parseAgentResponse(result.output);
+                                return [
+                                    2,
+                                    this.handleResponse(response)
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                (_this_logger1 = this.logger) === null || _this_logger1 === void 0 ? void 0 : _this_logger1.error('Error running chat agent', {
+                                    agentName: this.name,
+                                    error: _instanceof$1(error, Error) ? error.message : 'Unknown error',
+                                    userPrompt: userPrompt ? 'Prompt object' : 'none'
+                                });
+                                return [
+                                    2,
+                                    null
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "createExecutor",
+            value: function createExecutor(systemPrompt, options) {
+                return _async_to_generator$1(function() {
+                    var model, dynamicTools, systemPromptText, systemTemplate, humanTemplate, prompt, agent;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                model = options.model.getModel();
+                                // Convert Tool instances to DynamicTool instances
+                                dynamicTools = options.tools.map(function(tool) {
+                                    return tool.getDynamicTool();
+                                });
+                                // Combine LangChain framework rules with user-provided system prompts
+                                systemPromptText = "".concat(LANGCHAIN_FRAMEWORK_RULES, "\n\n").concat(systemPrompt.generate());
+                                systemTemplate = prompts.SystemMessagePromptTemplate.fromTemplate(systemPromptText);
+                                humanTemplate = prompts.HumanMessagePromptTemplate.fromTemplate('{input}');
+                                prompt = prompts.ChatPromptTemplate.fromMessages([
+                                    systemTemplate,
+                                    humanTemplate
+                                ]);
+                                return [
+                                    4,
+                                    agents.createStructuredChatAgent({
+                                        llm: model,
+                                        prompt: prompt,
+                                        tools: dynamicTools
+                                    })
+                                ];
+                            case 1:
+                                agent = _state.sent();
+                                return [
+                                    2,
+                                    agents.AgentExecutor.fromAgentAndTools({
+                                        agent: agent,
+                                        tools: dynamicTools
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "extractActionInput",
+            value: function extractActionInput(output) {
+                if ((typeof output === "undefined" ? "undefined" : _type_of(output)) === 'object' && output !== null) {
+                    return JSON.stringify(output);
+                }
+                if (typeof output !== 'string') {
+                    return String(output);
+                }
+                // Check for LangChain's action/action_input format first
+                var codeBlockMatch = output.match(/```(?:json)?\s*([\s\S]*?)```/i);
+                if (codeBlockMatch) {
+                    var content = codeBlockMatch[1].trim();
+                    try {
+                        var parsed = JSON.parse(content);
+                        if (parsed.action === 'Final Answer' && parsed.action_input) {
+                            return JSON.stringify(parsed.action_input);
+                        }
+                    } catch (e) {
+                    // Fall through to return original content
+                    }
+                    return content;
+                }
+                // Fallback: Look for "Final Answer:" pattern
+                if (output.includes('Final Answer:')) {
+                    var actionInputMatch = output.match(/Final Answer:\s*([\s\S]*?)$/i);
+                    if (actionInputMatch) {
+                        return actionInputMatch[1].trim();
+                    }
+                }
+                return output;
+            }
+        },
+        {
+            key: "handleResponse",
+            value: function handleResponse(response) {
+                var _this_logger;
+                if (response.shouldRespond && response.message) {
+                    var _this_logger1;
+                    (_this_logger1 = this.logger) === null || _this_logger1 === void 0 ? void 0 : _this_logger1.info('Agent responding with message', {
+                        agentName: this.name
+                    });
+                    return response.message;
+                }
+                if (!response.shouldRespond) {
+                    var _this_logger2;
+                    (_this_logger2 = this.logger) === null || _this_logger2 === void 0 ? void 0 : _this_logger2.info('Agent chose not to respond', {
+                        agentName: this.name,
+                        reason: response.reason
+                    });
+                    return null;
+                }
+                (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : _this_logger.error('Invalid agent response state', {
+                    agentName: this.name,
+                    response: response
+                });
+                return null;
+            }
+        },
+        {
+            key: "parseAgentResponse",
+            value: function parseAgentResponse(output) {
+                try {
+                    // Handle LangChain's action/action_input format
+                    var processedOutput = this.extractActionInput(output);
+                    return this.responseParser.parse(processedOutput);
+                } catch (error) {
+                    var _this_logger;
+                    (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : _this_logger.error('Failed to parse agent response', {
+                        agentName: this.name,
+                        error: _instanceof$1(error, Error) ? error.message : 'Unknown error',
+                        rawOutput: output
+                    });
+                    throw new Error('Invalid agent response format');
+                }
+            }
+        },
+        {
+            key: "resolveUserInput",
+            value: function resolveUserInput(userPrompt) {
+                if (!userPrompt) {
+                    return 'Please analyze the current situation and respond if appropriate.';
+                }
+                return userPrompt.generate();
+            }
+        }
+    ]);
+    return ChatAgentAdapter;
+}();
+
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$3(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$3(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$3(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$3(target, key, source[key]);
+        });
+    }
+    return target;
+}
+/**
+ * OpenRouter adapter that provides access to various models through OpenRouter's API
+ */ var OpenRouterModelAdapter = /*#__PURE__*/ function() {
+    function OpenRouterModelAdapter(config) {
+        _class_call_check$3(this, OpenRouterModelAdapter);
+        _define_property$3(this, "model", void 0);
+        this.model = new openai.ChatOpenAI({
+            configuration: {
+                baseURL: 'https://openrouter.ai/api/v1',
+                defaultHeaders: _object_spread({}, config.websiteUrl && {
+                    'HTTP-Referer': config.websiteUrl
+                }, config.title && {
+                    'X-Title': config.title
+                })
+            },
+            modelName: config.modelName,
+            openAIApiKey: config.apiKey
+        });
+    }
+    _create_class$3(OpenRouterModelAdapter, [
+        {
+            key: "getModel",
+            value: function getModel() {
+                return this.model;
+            }
+        }
+    ]);
+    return OpenRouterModelAdapter;
+}();
+
+/**
+ * Specifies the agent's area of expertise.
+ * This helps focus the agent's knowledge and the context of its responses.
+ */ var DOMAIN = {
+    ACADEMIC_RESEARCH: "\n<DOMAIN>\nYour expertise is in academic research. You are familiar with scholarly writing, peer-review processes, and formal citation methods.\n</DOMAIN>",
+    BUSINESS_STRATEGY: "\n<DOMAIN>\nYour expertise is in business strategy, including market analysis, competitive positioning, and operational planning.\n</DOMAIN>",
+    DATA_SCIENCE: "\n<DOMAIN>\nYour expertise is in data science, including statistical analysis, machine learning, and data visualization.\n</DOMAIN>",
+    GENERAL: "\n<DOMAIN>\nYou are a generalist with broad knowledge across many subjects.\n</DOMAIN>",
+    SOFTWARE_ENGINEERING: "\n<DOMAIN>\nYour expertise is in software engineering, including programming languages, system architecture, design patterns, and development best practices.\n</DOMAIN>"
+};
+
+/**
+ * Governs the agent's internal logic for responding and using tools.
+ */ var AGENT_LOGIC = {
+    ALWAYS_RESPOND: "\n<AGENT_LOGIC>\nAlways provide a response to the user's input, even if it's just to state that you cannot fulfill the request.\n</AGENT_LOGIC>",
+    SELECTIVE_RESPONSE: "\n<AGENT_LOGIC>\nOnly respond when you can provide a valuable, relevant, and substantive contribution.\nIf a response is not necessary, state that you have nothing to add.\n</AGENT_LOGIC>",
+    TOOL_FIRST: "\n<AGENT_LOGIC>\nBefore formulating a response, always prioritize using your available tools to gather the most current and accurate information.\n</AGENT_LOGIC>"
+};
+
+/**
+ * Defines the agent's primary cognitive skills and capabilities.
+ */ var AGENT_SKILLS = {
+    CREATIVE_IDEATION: "\n<AGENT_SKILL>\nYou excel at brainstorming, generating novel ideas, and thinking outside the box.\n</AGENT_SKILL>",
+    INFORMATION_SYNTHESIS: "\n<AGENT_SKILL>\nYou are skilled at gathering and synthesizing information from multiple sources to provide a comprehensive answer.\n</AGENT_SKILL>",
+    PROBLEM_SOLVING: "\n<AGENT_SKILL>\nYou are skilled at analyzing complex problems, breaking them down into manageable parts, and proposing systematic solutions.\n</AGENT_SKILL>"
+};
+
+/**
+ * Core, non-negotiable rules that guide the agent's operation.
+ * These define fundamental principles like safety, ethics, and factuality.
+ */ var DIRECTIVES = {
+    BE_ETHICAL: "\n<DIRECTIVE>\nAdhere to the highest ethical standards. Do not promote hate speech, discrimination, or violence.\nRespect user privacy and do not ask for or store personally identifiable information.\n</DIRECTIVE>",
+    BE_FACTUAL: "\n<DIRECTIVE>\nPrioritize accuracy and rely on verifiable information.\nIf you are uncertain about an answer, state your uncertainty clearly.\nDo not invent facts or statistics. When possible, cite credible sources.\n</DIRECTIVE>",
+    BE_SAFE: "\n<DIRECTIVE>\nDo not provide instructions or information that is illegal, dangerous, or harmful.\nRefuse to engage with requests that could cause real-world harm.\nPrioritize user safety and well-being in all responses.\n</DIRECTIVE>"
+};
+
+/**
+ * Defines the structural format of the agent's output.
+ */ var FORMAT = {
+    JSON: "\n<FORMAT>\nRespond ONLY with a valid, well-formed JSON object.\nDo not include any explanatory text or markdown formatting outside of the JSON structure.\n</FORMAT>",
+    MARKDOWN: "\n<FORMAT>\nUse Markdown for clear, structured responses.\nEmploy headings, lists, bold/italic text, and code blocks to improve readability.\n</FORMAT>",
+    PLAIN_TEXT: "\n<FORMAT>\nRespond in plain text without any special formatting, lists, or structural elements.\n</FORMAT>",
+    STEP_BY_STEP: "\n<FORMAT>\nBreak down instructions or processes into a clear, numbered, step-by-step list.\nEnsure each step is a distinct, actionable item.\n</FORMAT>"
+};
+
+/**
+ * Defines the natural language for the agent's responses, including proficiency level.
+ */ var LANGUAGE = {
+    ENGLISH_NATIVE: "\n<LANGUAGE>\nRespond in natural, fluent English as a native speaker would.\nUse idiomatic expressions, varied vocabulary, and natural sentence flow.\n</LANGUAGE>",
+    ENGLISH_SIMPLE: "\n<LANGUAGE>\nUse simple, clear English that's easy to understand for non-native speakers.\nAvoid complex grammar, idioms, and sophisticated vocabulary.\n</LANGUAGE>",
+    FRENCH_NATIVE: "\n<LANGUAGE>\nR\xe9pondez en fran\xe7ais naturel et fluide comme le ferait un locuteur natif.\nUtilisez des expressions idiomatiques et un vocabulaire vari\xe9.\n</LANGUAGE>",
+    FRENCH_SIMPLE: "\n<LANGUAGE>\nUtilisez un fran\xe7ais simple et clair, facile \xe0 comprendre.\n\xc9vitez la grammaire complexe et le vocabulaire sophistiqu\xe9.\n</LANGUAGE>",
+    SPANISH_NATIVE: "\n<LANGUAGE>\nResponde en espa\xf1ol natural y fluido como lo har\xeda un hablante nativo.\nUsa expresiones idiom\xe1ticas y vocabulario variado.\n</LANGUAGE>",
+    SPANISH_SIMPLE: "\n<LANGUAGE>\nUsa espa\xf1ol simple y claro que sea f\xe1cil de entender para no nativos.\nEvita la gram\xe1tica compleja y el vocabulario sofisticado.\n</LANGUAGE>"
+};
+
+/**
+ * Defines the "who" of the agent—its role and character.
+ * This sets the overall personality and interaction style.
+ */ var PERSONA = {
+    COMMUNITY_ANIMATOR: "\n<PERSONA>\nYou are the Community Animator, the heart and soul of a digital community like Discord.\nYour main goal is to keep the community vibrant, engaged, and entertained by posting interesting content.\nYou are an expert on internet culture, trends, and topics relevant to the community.\n</PERSONA>",
+    CREATIVE_PARTNER: "\n<PERSONA>\nYou are a creative partner, here to help brainstorm and explore new ideas.\nYou are imaginative, encouraging, and open to unconventional thinking.\nYour goal is to inspire and collaborate.\n</PERSONA>",
+    EXPERT_ADVISOR: "\n<PERSONA>\nYou are an expert advisor in your specified domain.\nYou provide authoritative, well-reasoned guidance.\nYour tone is confident, knowledgeable, and objective.\n</PERSONA>",
+    SUPPORT_AGENT: "\n<PERSONA>\nYou are a friendly and empathetic support agent.\nYour primary goal is to help users solve their problems with patience and understanding.\nYou are a good listener and provide clear, step-by-step assistance.\n</PERSONA>",
+    TUTOR: "\n<PERSONA>\nYou are a patient and knowledgeable tutor.\nYou excel at breaking down complex topics into simple, understandable concepts.\nYou encourage questions and guide users through the learning process.\n</PERSONA>"
+};
+
+/**
+ * Determines the emotional flavor and attitude of the agent's language.
+ */ var TONE = {
+    EMPATHETIC: "\n<TONE>\nAdopt a warm, understanding, and supportive tone.\nAcknowledge the user's feelings and show you are listening.\n</TONE>",
+    HUMOROUS: "\n<TONE>\nEmploy light-hearted humor, wit, and cleverness.\nKeep the mood fun and engaging, but avoid inappropriate or offensive jokes.\n</TONE>",
+    NEUTRAL: "\n<TONE>\nMaintain an impartial, objective, and straightforward tone.\nAvoid emotional language and stick to the facts.\n</TONE>",
+    PROFESSIONAL: "\n<TONE>\nUse a formal, respectful, and clear tone.\nStructure your communication logically and avoid slang or overly casual language.\n</TONE>"
+};
+
+/**
+ * Controls the level of detail and length of the agent's responses.
+ */ var VERBOSITY = {
+    CONCISE: "\n<VERBOSITY>\nProvide brief, to-the-point answers.\nFocus only on the most critical information and omit background details unless requested.\n</VERBOSITY>",
+    DETAILED: "\n<VERBOSITY>\nOffer comprehensive and thorough responses.\nInclude background information, context, examples, and potential edge cases.\n</VERBOSITY>",
+    NORMAL: "\n<VERBOSITY>\nProvide a balanced level of detail, sufficient for a clear understanding without being overwhelming.\n</VERBOSITY>"
+};
+
+/**
+ * Provides ready-to-use combinations of prompt parts for common use cases.
+ */ var PRESETS = {
+    /**
+     * A creative partner for brainstorming and ideation.
+     */ CREATIVE_BRAINSTORMER: [
+        DIRECTIVES.BE_ETHICAL,
+        PERSONA.CREATIVE_PARTNER,
+        DOMAIN.GENERAL,
+        TONE.HUMOROUS,
+        VERBOSITY.NORMAL,
+        FORMAT.MARKDOWN,
+        AGENT_LOGIC.ALWAYS_RESPOND,
+        AGENT_SKILLS.CREATIVE_IDEATION
+    ],
+    /**
+     * A fun and engaging community animator for platforms like Discord.
+     */ DISCORD_COMMUNITY_ANIMATOR: [
+        DIRECTIVES.BE_SAFE,
+        PERSONA.COMMUNITY_ANIMATOR,
+        DOMAIN.GENERAL,
+        TONE.HUMOROUS,
+        VERBOSITY.NORMAL,
+        FORMAT.MARKDOWN,
+        AGENT_LOGIC.ALWAYS_RESPOND,
+        AGENT_SKILLS.CREATIVE_IDEATION
+    ],
+    /**
+     * A friendly and empathetic support agent for general queries.
+     */ EMPATHETIC_SUPPORT_AGENT: [
+        DIRECTIVES.BE_SAFE,
+        DIRECTIVES.BE_ETHICAL,
+        PERSONA.SUPPORT_AGENT,
+        DOMAIN.GENERAL,
+        TONE.EMPATHETIC,
+        VERBOSITY.NORMAL,
+        FORMAT.STEP_BY_STEP,
+        AGENT_LOGIC.ALWAYS_RESPOND,
+        AGENT_SKILLS.PROBLEM_SOLVING
+    ]
+};
+
+var PROMPTS = {
+    AGENT_LOGIC: AGENT_LOGIC,
+    AGENT_SKILLS: AGENT_SKILLS,
+    DIRECTIVES: DIRECTIVES,
+    DOMAIN: DOMAIN,
+    FORMAT: FORMAT,
+    LANGUAGE: LANGUAGE,
+    PERSONA: PERSONA,
+    PRESETS: PRESETS,
+    TONE: TONE,
+    VERBOSITY: VERBOSITY
+};
+
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$2(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * System prompt adapter that generates a system prompt from a list of strings
+ */ var SystemPromptAdapter = /*#__PURE__*/ function() {
+    function SystemPromptAdapter() {
+        for(var _len = arguments.length, prompts = new Array(_len), _key = 0; _key < _len; _key++){
+            prompts[_key] = arguments[_key];
+        }
+        _class_call_check$2(this, SystemPromptAdapter);
+        _define_property$2(this, "finalPrompt", void 0);
+        var flattenedPrompts = prompts.flat();
+        this.finalPrompt = flattenedPrompts.join('\n\n');
+    }
+    _create_class$2(SystemPromptAdapter, [
+        {
+            key: "generate",
+            value: function generate() {
+                return this.finalPrompt;
+            }
+        }
+    ]);
+    return SystemPromptAdapter;
+}();
+
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * User prompt adapter that generates a user prompt from a list of strings
+ */ var UserPromptAdapter = /*#__PURE__*/ function() {
+    function UserPromptAdapter() {
+        for(var _len = arguments.length, prompts = new Array(_len), _key = 0; _key < _len; _key++){
+            prompts[_key] = arguments[_key];
+        }
+        _class_call_check$1(this, UserPromptAdapter);
+        _define_property$1(this, "finalPrompt", void 0);
+        var flattenedPrompts = prompts.flat();
+        this.finalPrompt = flattenedPrompts.join('\n\n');
+    }
+    _create_class$1(UserPromptAdapter, [
+        {
+            key: "generate",
+            value: function generate() {
+                return this.finalPrompt;
+            }
+        }
+    ]);
+    return UserPromptAdapter;
+}();
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, 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
+        };
+    }
+}
+/**
+ * Safe tool adapter that provides error handling and logging for LangChain tools
+ */ var SafeToolAdapter = /*#__PURE__*/ function() {
+    function SafeToolAdapter(config) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        _class_call_check(this, SafeToolAdapter);
+        _define_property(this, "config", void 0);
+        _define_property(this, "options", void 0);
+        _define_property(this, "dynamicTool", void 0);
+        this.config = config;
+        this.options = options;
+        var logger = options.logger, schema = options.schema;
+        if (schema) {
+            // Use DynamicStructuredTool for parameterized tools
+            this.dynamicTool = new tools.DynamicStructuredTool({
+                description: config.description,
+                func: function(args) {
+                    return _async_to_generator(function() {
+                        var error, errorMessage;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _state.trys.push([
+                                        0,
+                                        2,
+                                        ,
+                                        3
+                                    ]);
+                                    return [
+                                        4,
+                                        config.execute(args)
+                                    ];
+                                case 1:
+                                    return [
+                                        2,
+                                        _state.sent()
+                                    ];
+                                case 2:
+                                    error = _state.sent();
+                                    errorMessage = _instanceof(error, Error) ? error.message : String(error);
+                                    logger === null || logger === void 0 ? void 0 : logger.error("Unexpected error in ".concat(config.name), {
+                                        args: args,
+                                        error: errorMessage,
+                                        toolName: config.name
+                                    });
+                                    return [
+                                        2,
+                                        "Tool ".concat(config.name, " failed to execute")
+                                    ];
+                                case 3:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
+                },
+                name: config.name,
+                schema: schema
+            });
+        } else {
+            // Use DynamicTool for simple tools
+            this.dynamicTool = new tools.DynamicTool({
+                description: config.description,
+                func: function() {
+                    return _async_to_generator(function() {
+                        var error, errorMessage;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _state.trys.push([
+                                        0,
+                                        2,
+                                        ,
+                                        3
+                                    ]);
+                                    return [
+                                        4,
+                                        config.execute()
+                                    ];
+                                case 1:
+                                    return [
+                                        2,
+                                        _state.sent()
+                                    ];
+                                case 2:
+                                    error = _state.sent();
+                                    errorMessage = _instanceof(error, Error) ? error.message : String(error);
+                                    logger === null || logger === void 0 ? void 0 : logger.error("Unexpected error in ".concat(config.name), {
+                                        error: errorMessage,
+                                        toolName: config.name
+                                    });
+                                    return [
+                                        2,
+                                        "Tool ".concat(config.name, " failed to execute")
+                                    ];
+                                case 3:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
+                },
+                name: config.name
+            });
+        }
+    }
+    _create_class(SafeToolAdapter, [
+        {
+            /**
+     * Get the underlying LangChain DynamicTool instance
+     */ key: "getDynamicTool",
+            value: function getDynamicTool() {
+                return this.dynamicTool;
+            }
+        }
+    ]);
+    return SafeToolAdapter;
+}();
+
+exports.AIResponseParser = AIResponseParser;
+exports.ChatAgentAdapter = ChatAgentAdapter;
+exports.OpenRouterAdapter = OpenRouterModelAdapter;
+exports.PROMPTS = PROMPTS;
+exports.SafeToolAdapter = SafeToolAdapter;
+exports.SystemPromptAdapter = SystemPromptAdapter;
+exports.UserPromptAdapter = UserPromptAdapter;