@jterrazz/intelligence 1.0.0 → 1.1.1

package/dist/index.cjs

@@ -18,7 +18,7 @@ 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) {
+function _class_call_check$7(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
@@ -40,7 +40,7 @@ function _construct(Parent, args, Class) {
     }
     return _construct.apply(null, arguments);
 }
-function _define_property$6(obj, key, value) {
+function _define_property$7(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -76,7 +76,7 @@ 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")) {
+    if (call && (_type_of$1(call) === "object" || typeof call === "function")) {
         return call;
     }
     return _assert_this_initialized(self);
@@ -88,7 +88,7 @@ function _set_prototype_of(o, p) {
     };
     return _set_prototype_of(o, p);
 }
-function _type_of$2(obj) {
+function _type_of$1(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
@@ -129,11 +129,11 @@ function _is_native_reflect_construct() {
 var AIResponseParserError = /*#__PURE__*/ function(Error1) {
     _inherits(AIResponseParserError, Error1);
     function AIResponseParserError(message, cause, text) {
-        _class_call_check$6(this, AIResponseParserError);
+        _class_call_check$7(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;
+        ]), _define_property$7(_this, "cause", void 0), _define_property$7(_this, "text", void 0), _this.cause = cause, _this.text = text;
         _this.name = 'AIResponseParserError';
         return _this;
     }
@@ -148,12 +148,12 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
-function _class_call_check$5(instance, Constructor) {
+function _class_call_check$6(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _defineProperties$5(target, props) {
+function _defineProperties$6(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -162,11 +162,11 @@ function _defineProperties$5(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$5(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
+function _create_class$6(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$6(Constructor.prototype, protoProps);
     return Constructor;
 }
-function _define_property$5(obj, key, value) {
+function _define_property$6(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -179,7 +179,7 @@ function _define_property$5(obj, key, value) {
     }
     return obj;
 }
-function _instanceof$2(left, right) {
+function _instanceof$3(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -216,7 +216,7 @@ function _non_iterable_rest() {
 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) {
+function _type_of(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
@@ -232,11 +232,11 @@ function _unsupported_iterable_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);
+        _class_call_check$6(this, AIResponseParser);
+        _define_property$6(this, "schema", void 0);
         this.schema = schema;
     }
-    _create_class$5(AIResponseParser, [
+    _create_class$6(AIResponseParser, [
         {
             key: "parse",
             value: /**
@@ -248,7 +248,7 @@ function _unsupported_iterable_to_array(o, minLen) {
                     var unescapedJson = this.unescapeJsonValues(json);
                     return this.schema.parse(unescapedJson);
                 } catch (error) {
-                    if (_instanceof$2(error, v4.z.ZodError)) {
+                    if (_instanceof$3(error, v4.z.ZodError)) {
                         throw new AIResponseParserError('Failed to validate response against schema', error, text);
                     }
                     throw error;
@@ -288,16 +288,16 @@ function _unsupported_iterable_to_array(o, minLen) {
             value: /**
      * Converts value to appropriate primitive type based on schema
      */ function convertToPrimitive(value, schema) {
-                if (_instanceof$2(schema, v4.z.ZodString)) {
+                if (_instanceof$3(schema, v4.z.ZodString)) {
                     return String(value);
                 }
-                if (_instanceof$2(schema, v4.z.ZodNumber)) {
+                if (_instanceof$3(schema, v4.z.ZodNumber)) {
                     return Number(value);
                 }
-                if (_instanceof$2(schema, v4.z.ZodBoolean)) {
+                if (_instanceof$3(schema, v4.z.ZodBoolean)) {
                     return Boolean(value);
                 }
-                if (_instanceof$2(schema, v4.z.ZodNull)) {
+                if (_instanceof$3(schema, v4.z.ZodNull)) {
                     return null;
                 }
                 return value;
@@ -340,13 +340,13 @@ function _unsupported_iterable_to_array(o, minLen) {
             value: /**
      * Extracts and parses JSON from text based on schema type
      */ function extractJsonFromText(text) {
-                if (_instanceof$2(this.schema, v4.z.ZodArray)) {
+                if (_instanceof$3(this.schema, v4.z.ZodArray)) {
                     return this.extractArray(text);
                 }
-                if (_instanceof$2(this.schema, v4.z.ZodObject)) {
+                if (_instanceof$3(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)) {
+                if (_instanceof$3(this.schema, v4.z.ZodString) || _instanceof$3(this.schema, v4.z.ZodNumber) || _instanceof$3(this.schema, v4.z.ZodBoolean) || _instanceof$3(this.schema, v4.z.ZodNull)) {
                     return this.extractPrimitive(text, this.schema);
                 }
                 throw new AIResponseParserError('Unsupported schema type', undefined, text);
@@ -438,7 +438,7 @@ function _unsupported_iterable_to_array(o, minLen) {
                         return _this.unescapeJsonValues(item);
                     });
                 }
-                if ((typeof json === "undefined" ? "undefined" : _type_of$1(json)) === 'object' && json !== null) {
+                if ((typeof json === "undefined" ? "undefined" : _type_of(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 [
@@ -469,7 +469,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     return AIResponseParser;
 }();
 
-function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -483,27 +483,27 @@ function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$1(fn) {
+function _async_to_generator$2(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);
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
-function _class_call_check$4(instance, Constructor) {
+function _class_call_check$5(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _defineProperties$4(target, props) {
+function _defineProperties$5(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -512,11 +512,11 @@ function _defineProperties$4(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$4(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$4(Constructor.prototype, protoProps);
+function _create_class$5(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$5(Constructor.prototype, protoProps);
     return Constructor;
 }
-function _define_property$4(obj, key, value) {
+function _define_property$5(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -529,18 +529,14 @@ function _define_property$4(obj, key, value) {
     }
     return obj;
 }
-function _instanceof$1(left, right) {
+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 _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _ts_generator$1(thisArg, body) {
+function _ts_generator$2(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -631,84 +627,88 @@ function _ts_generator$1(thisArg, body) {
         };
     }
 }
-// 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>';
+var SYSTEM_PROMPT_TEMPLATE = '\n<OBJECTIVE>\n{mission_prompt}\n</OBJECTIVE>\n\n<OUTPUT_FORMAT>\nCRITICAL: The format instructions in this section are the ONLY valid way to structure your response. Any formatting guidelines within the <OBJECTIVE> section (like message templates) apply ONLY to the content that goes inside the "RESPOND: " part of your final answer.\n\nYou have two ways to respond:\n\n1.  **Call a tool** to gather information. For this, you MUST output a JSON blob with the tool\'s name and its input.\n    *Valid tool names are: {tool_names}*\n    ```json\n    {{\n      "action": "tool_name_to_use",\n      "action_input": "the input for the tool, or an empty object {{}} if no input is needed"\n    }}\n    ```\n\n2.  **Provide the Final Answer** once you have enough information. For this, you MUST output a JSON blob with the "Final Answer" action. The input must start with "RESPOND: " or "SILENT: ".\n    - To send a message:\n      ```json\n      {{\n        "action": "Final Answer",\n        "action_input": "RESPOND: <your response message>"\n      }}\n      ```\n    - To stay silent:\n      ```json\n      {{\n        "action": "Final Answer",\n        "action_input": "SILENT: <your reason for staying silent>"\n      }}\n      ```\n</OUTPUT_FORMAT>\n\n<EXECUTION_CONTEXT>\nThis is internal data for your reference.\n\n<TOOLS>\n{tools}\n</TOOLS>\n\n<WORKING_MEMORY>\nThis is your internal thought process and previous tool usage.\n{agent_scratchpad}\n</WORKING_MEMORY>\n</EXECUTION_CONTEXT>\n';
 /**
- * Chat agent adapter that provides structured chat capabilities with optional responses
+ * An advanced agent that uses tools and a structured prompt to engage in conversational chat.
+ * It can decide whether to respond or remain silent and supports schema-validated 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);
+    function ChatAgentAdapter(name, options) {
+        _class_call_check$5(this, ChatAgentAdapter);
+        _define_property$5(this, "name", void 0);
+        _define_property$5(this, "options", void 0);
         this.name = name;
-        this.logger = options.logger;
-        this.responseParser = new AIResponseParser(AgentResponseSchema);
-        this.executorPromise = this.createExecutor(systemPrompt, options);
+        this.options = options;
     }
-    _create_class$4(ChatAgentAdapter, [
+    _create_class$5(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) {
+                return _async_to_generator$2(function() {
+                    var _this_options_logger, _this_options_logger1, executor, userInput, result, agentResponse, _this_options_logger2, _agentResponse_message, message, _this_options_logger3, _this_options_logger4, error, _this_options_logger5;
+                    return _ts_generator$2(this, function(_state) {
                         switch(_state.label){
                             case 0:
+                                (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.debug("[".concat(this.name, "] Starting chat execution."));
+                                _state.label = 1;
+                            case 1:
                                 _state.trys.push([
-                                    0,
-                                    3,
+                                    1,
+                                    4,
                                     ,
-                                    4
+                                    5
                                 ]);
                                 return [
                                     4,
-                                    this.executorPromise
+                                    this.createExecutor()
                                 ];
-                            case 1:
+                            case 2:
                                 executor = _state.sent();
-                                input = this.resolveUserInput(userPrompt);
+                                userInput = this.resolveUserInput(userPrompt);
                                 return [
                                     4,
                                     executor.invoke({
-                                        input: input
+                                        input: userInput
                                     })
                                 ];
-                            case 2:
+                            case 3:
                                 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)
+                                (_this_options_logger1 = this.options.logger) === null || _this_options_logger1 === void 0 ? void 0 : _this_options_logger1.debug("[".concat(this.name, "] Agent execution completed."), {
+                                    hasOutput: 'output' in result
                                 });
-                                if (!result || typeof result.output === 'undefined') {
-                                    throw new Error('Agent returned invalid result structure');
+                                if (!result || typeof result.output !== 'string') {
+                                    throw new Error('Agent returned an invalid result structure.');
+                                }
+                                agentResponse = this.parseAgentOutput(result.output);
+                                if (!agentResponse.shouldRespond) {
+                                    (_this_options_logger2 = this.options.logger) === null || _this_options_logger2 === void 0 ? void 0 : _this_options_logger2.info("[".concat(this.name, "] Agent chose to remain silent."), {
+                                        reason: agentResponse.reason
+                                    });
+                                    return [
+                                        2,
+                                        null
+                                    ];
+                                }
+                                message = (_agentResponse_message = agentResponse.message) !== null && _agentResponse_message !== void 0 ? _agentResponse_message : '';
+                                if (this.options.schema) {
+                                    this.validateResponseContent(message, this.options.schema);
+                                    (_this_options_logger3 = this.options.logger) === null || _this_options_logger3 === void 0 ? void 0 : _this_options_logger3.info("[".concat(this.name, "] Execution finished; response content validated."));
+                                } else {
+                                    (_this_options_logger4 = this.options.logger) === null || _this_options_logger4 === void 0 ? void 0 : _this_options_logger4.info("[".concat(this.name, "] Execution finished."));
                                 }
-                                response = this.parseAgentResponse(result.output);
                                 return [
                                     2,
-                                    this.handleResponse(response)
+                                    message
                                 ];
-                            case 3:
+                            case 4:
                                 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'
+                                (_this_options_logger5 = this.options.logger) === null || _this_options_logger5 === void 0 ? void 0 : _this_options_logger5.error("[".concat(this.name, "] Chat execution failed."), {
+                                    error: _instanceof$2(error, Error) ? error.message : 'Unknown error'
                                 });
                                 return [
                                     2,
                                     null
                                 ];
-                            case 4:
+                            case 5:
                                 return [
                                     2
                                 ];
@@ -719,31 +719,32 @@ var LANGCHAIN_FRAMEWORK_RULES = '\n<AGENT_FRAMEWORK>\nYou are a chat agent pilot
         },
         {
             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) {
+            value: function createExecutor() {
+                return _async_to_generator$2(function() {
+                    var model, tools, prompt, agent;
+                    return _ts_generator$2(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                model = options.model.getModel();
-                                // Convert Tool instances to DynamicTool instances
-                                dynamicTools = options.tools.map(function(tool) {
+                                model = this.options.model.getModel();
+                                tools = this.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
+                                    [
+                                        'system',
+                                        SYSTEM_PROMPT_TEMPLATE.replace('{mission_prompt}', this.options.systemPrompt.generate())
+                                    ],
+                                    [
+                                        'human',
+                                        '{input}'
+                                    ]
                                 ]);
                                 return [
                                     4,
                                     agents.createStructuredChatAgent({
                                         llm: model,
                                         prompt: prompt,
-                                        tools: dynamicTools
+                                        tools: tools
                                     })
                                 ];
                             case 1:
@@ -752,102 +753,365 @@ var LANGCHAIN_FRAMEWORK_RULES = '\n<AGENT_FRAMEWORK>\nYou are a chat agent pilot
                                     2,
                                     agents.AgentExecutor.fromAgentAndTools({
                                         agent: agent,
-                                        tools: dynamicTools
+                                        tools: tools,
+                                        verbose: this.options.verbose
                                     })
                                 ];
                         }
                     });
-                })();
+                }).call(this);
             }
         },
         {
-            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);
+            key: "parseAgentOutput",
+            value: function parseAgentOutput(output) {
+                var _this_options_logger;
+                var text = output.trim();
+                var respondMatch = text.match(/^RESPOND:\s*([\s\S]+)$/i);
+                if (respondMatch) {
+                    return {
+                        message: respondMatch[1].trim(),
+                        shouldRespond: true
+                    };
                 }
-                // 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;
+                var silentMatch = text.match(/^SILENT:\s*([\s\S]+)$/i);
+                if (silentMatch) {
+                    return {
+                        reason: silentMatch[1].trim(),
+                        shouldRespond: false
+                    };
                 }
-                // 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();
-                    }
+                (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.warn("[".concat(this.name, "] Agent output was missing 'RESPOND:' or 'SILENT:' prefix. Treating as a direct response."), {
+                    rawOutput: output
+                });
+                return {
+                    message: text,
+                    shouldRespond: true
+                };
+            }
+        },
+        {
+            key: "resolveUserInput",
+            value: function resolveUserInput(userPrompt) {
+                if (userPrompt) {
+                    return userPrompt.generate();
                 }
-                return output;
+                return 'Proceed with your instructions.';
             }
         },
         {
-            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
+            key: "validateResponseContent",
+            value: function validateResponseContent(content, schema) {
+                try {
+                    new AIResponseParser(schema).parse(content);
+                } catch (error) {
+                    var _this_options_logger;
+                    (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.error("[".concat(this.name, "] Failed to validate response content against schema."), {
+                        error: _instanceof$2(error, Error) ? error.message : 'Unknown error',
+                        rawContent: content
                     });
-                    return response.message;
+                    throw new Error('Invalid response content from model.');
                 }
-                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 ChatAgentAdapter;
+}();
+
+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 _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
+        };
+    }
+}
+/**
+ * A simple agent for direct, one-shot interactions with a model.
+ * It supports optional response parsing against a Zod schema but does not use tools.
+ */ var QueryAgentAdapter = /*#__PURE__*/ function() {
+    function QueryAgentAdapter(name, options) {
+        _class_call_check$4(this, QueryAgentAdapter);
+        _define_property$4(this, "name", void 0);
+        _define_property$4(this, "options", void 0);
+        this.name = name;
+        this.options = options;
+    }
+    _create_class$4(QueryAgentAdapter, [
+        {
+            key: "run",
+            value: function run(userPrompt) {
+                return _async_to_generator$1(function() {
+                    var _this_options_logger, content, _this_options_logger1, _this_options_logger2, error, _this_options_logger3;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.debug("[".concat(this.name, "] Starting query execution."));
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    this.invokeModel(userPrompt)
+                                ];
+                            case 2:
+                                content = _state.sent();
+                                if (this.options.schema) {
+                                    this.parseResponse(content, this.options.schema);
+                                    (_this_options_logger1 = this.options.logger) === null || _this_options_logger1 === void 0 ? void 0 : _this_options_logger1.info("[".concat(this.name, "] Execution finished and response parsed."));
+                                } else {
+                                    (_this_options_logger2 = this.options.logger) === null || _this_options_logger2 === void 0 ? void 0 : _this_options_logger2.info("[".concat(this.name, "] Execution finished."));
+                                }
+                                return [
+                                    2,
+                                    content
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                (_this_options_logger3 = this.options.logger) === null || _this_options_logger3 === void 0 ? void 0 : _this_options_logger3.error("[".concat(this.name, "] Execution failed."), {
+                                    error: _instanceof$1(error, Error) ? error.message : 'Unknown error'
+                                });
+                                return [
+                                    2,
+                                    null
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
                     });
-                    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;
+                }).call(this);
             }
         },
         {
-            key: "parseAgentResponse",
-            value: function parseAgentResponse(output) {
+            key: "invokeModel",
+            value: function invokeModel(userPrompt) {
+                return _async_to_generator$1(function() {
+                    var _this_options_logger, userInput, systemMessage, messages, _this_options_logger1, response, content;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                userInput = this.resolveUserInput(userPrompt);
+                                systemMessage = this.options.systemPrompt.generate();
+                                messages = [
+                                    {
+                                        content: systemMessage,
+                                        role: 'system'
+                                    },
+                                    {
+                                        content: userInput,
+                                        role: 'user'
+                                    }
+                                ];
+                                (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.debug("[".concat(this.name, "] Invoking model..."), {
+                                    hasSchema: !!this.options.schema
+                                });
+                                if (this.options.verbose) {
+                                    (_this_options_logger1 = this.options.logger) === null || _this_options_logger1 === void 0 ? void 0 : _this_options_logger1.info("[".concat(this.name, "] Sending messages to model..."), {
+                                        messages: messages
+                                    });
+                                }
+                                return [
+                                    4,
+                                    this.options.model.getModel().invoke(messages)
+                                ];
+                            case 1:
+                                response = _state.sent();
+                                content = response.content;
+                                if (typeof content !== 'string') {
+                                    throw new Error('Model returned a non-string content type.');
+                                }
+                                return [
+                                    2,
+                                    content
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "parseResponse",
+            value: function parseResponse(content, schema) {
                 try {
-                    // Handle LangChain's action/action_input format
-                    var processedOutput = this.extractActionInput(output);
-                    return this.responseParser.parse(processedOutput);
+                    new AIResponseParser(schema).parse(content);
                 } 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,
+                    var _this_options_logger;
+                    (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.error("[".concat(this.name, "] Failed to parse model response."), {
                         error: _instanceof$1(error, Error) ? error.message : 'Unknown error',
-                        rawOutput: output
+                        rawContent: content
                     });
-                    throw new Error('Invalid agent response format');
+                    throw new Error('Invalid response format from model.');
                 }
             }
         },
         {
             key: "resolveUserInput",
             value: function resolveUserInput(userPrompt) {
-                if (!userPrompt) {
-                    return 'Please analyze the current situation and respond if appropriate.';
+                if (userPrompt) {
+                    return userPrompt.generate();
                 }
-                return userPrompt.generate();
+                return 'Proceed with your instructions.';
             }
         }
     ]);
-    return ChatAgentAdapter;
+    return QueryAgentAdapter;
 }();
 
 function _class_call_check$3(instance, Constructor) {
@@ -901,16 +1165,19 @@ function _object_spread(target) {
  */ var OpenRouterModelAdapter = /*#__PURE__*/ function() {
     function OpenRouterModelAdapter(config) {
         _class_call_check$3(this, OpenRouterModelAdapter);
+        var _config_metadata, _config_metadata1;
         _define_property$3(this, "model", void 0);
+        var _config_maxTokens;
         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
+                defaultHeaders: _object_spread({}, ((_config_metadata = config.metadata) === null || _config_metadata === void 0 ? void 0 : _config_metadata.website) && {
+                    'HTTP-Referer': config.metadata.website
+                }, ((_config_metadata1 = config.metadata) === null || _config_metadata1 === void 0 ? void 0 : _config_metadata1.application) && {
+                    'X-Title': config.metadata.application
                 })
             },
+            maxTokens: (_config_maxTokens = config.maxTokens) !== null && _config_maxTokens !== void 0 ? _config_maxTokens : 64000,
             modelName: config.modelName,
             openAIApiKey: config.apiKey
         });
@@ -927,142 +1194,133 @@ function _object_spread(target) {
 }();
 
 /**
- * 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>"
+ * Specifies the agent's area of knowledge and expertise.
+ * This focuses the agent's responses within a specific context.
+ */ var DOMAINS = {
+    ACADEMIC_RESEARCH: "\n<Domain>\nYour knowledge is specialized in academic research. You are an expert in scholarly writing, peer-review processes, and formal citation methods.\n</Domain>",
+    BUSINESS_STRATEGY: "\n<Domain>\nYour knowledge is specialized in business strategy, including market analysis, competitive positioning, and operational planning.\n</Domain>",
+    DATA_SCIENCE: "\n<Domain>\nYour knowledge is specialized in data science, including statistical analysis, machine learning, and data visualization.\n</Domain>",
+    GENERAL: "\n<Domain>\nYou possess broad, generalist knowledge across a wide variety of subjects.\n</Domain>",
+    SOFTWARE_ENGINEERING: "\n<Domain>\nYour knowledge is specialized in software engineering. You are an expert in 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 required structural format for the agent's output.
+ */ var FORMATS = {
+    DISCORD_MARKDOWN: "\n<Format>\nYou MUST format your response using Discord-flavored Markdown (e.g., **bold**, *italics*, __underline__, `code`, ```code blocks```, > quotes).\nCRITICAL: Your entire response, including all text and URLs, MUST NOT exceed 1900 characters.\n</Format>",
+    JSON: "\n<Format>\nYou MUST respond ONLY with a single, valid, well-formed JSON object.\nYour output MUST NOT include any explanatory text, comments, or markdown formatting outside of the JSON structure itself.\n</Format>",
+    MARKDOWN: "\n<Format>\nYou MUST format your response using Markdown for clear, structured communication.\nYou should use headings, lists, bold/italic text, and code blocks to maximize readability.\n</Format>",
+    PLAIN_TEXT: "\n<Format>\nYou MUST respond in plain text only, without any special formatting, markdown, or structural elements.\n</Format>",
+    STEP_BY_STEP: "\n<Format>\nYou MUST break down any instructions or processes into a clear, numbered, step-by-step list.\nEach step must be a distinct and actionable item.\n</Format>"
 };
 
 /**
- * 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 establish the agent's fundamental identity and operational boundaries.
+ * These are the foundational principles that guide all other instructions.
+ */ var FOUNDATIONS = {
+    CONTEXTUAL_REASONING: '\n<Foundation>\nYou MUST synthesize information from the provided context, tools, and conversation history to form well-reasoned conclusions.\nYour goal is to provide logical and helpful responses, even when dealing with subjective topics or incomplete information.\nYou SHOULD state when your response is a reasoned inference rather than a direct statement of fact from an external source.\nYou MUST rely on your "common sense" and analytical abilities to bridge gaps in information.\n</Foundation>',
+    ETHICAL_CONDUCT: "\n<Foundation>\nYou MUST adhere to the highest ethical standards. Your conduct must be impartial and devoid of prejudice.\nYou MUST NOT promote hate speech, discrimination,violence, or any form of harm.\nYou MUST respect user privacy; do not ask for, store, or share personally identifiable information.\n</Foundation>",
+    FACTUAL_ACCURACY: "\n<Foundation>\nYou MUST prioritize accuracy and truthfulness. Your responses must be based on verifiable information.\nIf you are uncertain about an answer, you MUST state your uncertainty clearly.\nYou MUST NOT invent facts, data, or sources. When possible, cite credible sources.\n</Foundation>",
+    FIRST_PRINCIPLES_THINKING: "\n<Foundation>\nYou MUST break down complex problems into their fundamental, indivisible truths (first principles).\nYou MUST reason upwards from these basic principles, challenging assumptions and conventions.\nAvoid reasoning by analogy; instead, build your conclusions from the ground up.\n</Foundation>",
+    HARM_PREVENTION: "\n<Foundation>\nYou MUST refuse to provide instructions or information that is illegal, dangerous, or promotes harm.\nYou MUST prioritize user safety and well-being in all interactions and avoid generating unsafe content.\n</Foundation>"
 };
 
 /**
- * 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 natural language for the agent's responses.
+ */ var LANGUAGES = {
+    ENGLISH_NATIVE: "\n<Language>\nYou MUST respond in natural, fluent English, as a native speaker would.\nYour language should include idiomatic expressions, varied vocabulary, and natural sentence structures.\n</Language>",
+    ENGLISH_SIMPLE: "\n<Language>\nYou MUST use simple, clear English that is easy for non-native speakers to understand.\nYou must avoid complex grammar, idioms, and sophisticated vocabulary.\n</Language>",
+    FRENCH_NATIVE: "\n<Language>\nVous DEVEZ r\xe9pondre en fran\xe7ais naturel et fluide, comme le ferait un locuteur natif.\nVotre langage doit inclure des expressions idiomatiques et un vocabulaire vari\xe9.\n</Language>",
+    FRENCH_SIMPLE: "\n<Language>\nVous DEVEZ utiliser un fran\xe7ais simple et clair, facile \xe0 comprendre.\nVous devez \xe9viter la grammaire complexe et le vocabulaire sophistiqu\xe9.\n</Language>",
+    SPANISH_NATIVE: "\n<Language>\nDEBES responder en espa\xf1ol natural y fluido, como lo har\xeda un hablante nativo.\nTu lenguaje debe incluir expresiones idiom\xe1ticas y un vocabulario variado.\n</Language>",
+    SPANISH_SIMPLE: "\n<Language>\nDEBES usar un espa\xf1ol simple y claro que sea f\xe1cil de entender para no nativos.\nDebes evitar la gram\xe1tica compleja y el vocabulario sofisticado.\n</Language>"
 };
 
 /**
- * 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 agent's core identity, role, and purpose, integrating key skills.
+ * This sets the primary character and interaction style.
+ */ var PERSONAS = {
+    COMMUNITY_ANIMATOR: "\n<Persona>\nYou are the Community Animator, the vibrant heart of a digital community (e.g., Discord).\nYour purpose is to keep the community active, engaged, and positive.\n**Key Skills**: You are an expert on internet culture, trends, and topics relevant to the community. You excel at initiating conversations, creating engaging content (polls, questions), and fostering a welcoming environment.\n</Persona>",
+    CREATIVE_PARTNER: "\n<Persona>\nYou are a Creative Partner, an imaginative collaborator for brainstorming and exploration.\nYour purpose is to help users generate and develop novel ideas.\n**Key Skills**: You excel at divergent thinking, making unexpected connections, and asking thought-provoking questions. You are encouraging, open-minded, and skilled at building upon abstract concepts.\n</Persona>",
+    EXPERT_ADVISOR: "\n<Persona>\nYou are an Expert Advisor in your specified domain.\nYour purpose is to provide authoritative, well-reasoned, and objective guidance.\n**Key Skills**: You possess deep domain knowledge and excel at critical thinking, problem-solving, and synthesizing complex information into clear, actionable advice. Your communication is precise and confident.\n</Persona>",
+    HUMAN_LIKE_CONTRIBUTOR: "\n<Persona>\nYou are a Human-Like Contributor, a thoughtful and engaging participant in a group chat.\nYour purpose is to interact in a way that is indistinguishable from a human, fostering natural and coherent conversations.\n**Key Skills**: You excel at maintaining conversational context, ensuring your contributions are a logical continuation of past interactions. You avoid repetition and can proactively initiate new topics when appropriate. Your style is natural, personal, and adaptive.\n</Persona>",
+    SUPPORT_AGENT: "\n<Persona>\nYou are a friendly, patient, and empathetic Support Agent.\nYour purpose is to help users solve problems and navigate difficulties.\n**Key Skills**: You are an excellent listener and a clear communicator. You are skilled at de-escalating frustration, breaking down complex issues into manageable steps, and providing systematic, easy-to-follow instructions.\n</Persona>",
+    TUTOR: "\n<Persona>\nYou are a patient, knowledgeable, and encouraging Tutor.\nYour purpose is to help users learn and understand complex subjects.\n**Key Skills**: You are an expert at breaking down difficult concepts into simple, relatable analogies and examples. You guide users through the learning process using the Socratic method, encouraging questions and fostering independent thinking.\n</Persona>"
 };
 
 /**
- * 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>"
+ * Defines the agent's strategic approach to when and how it should respond.
+ */ var RESPONSE = {
+    ALWAYS_ENGAGE: "\n<ResponseStrategy>\nYou must always provide a response to the user's input. Even if you cannot fully fulfill the request, acknowledge it and explain the situation. Your primary directive is to be responsive.\n</ResponseStrategy>",
+    CONTEXTUAL_ENGAGEMENT: "\n<ResponseStrategy>\nBefore responding, you must analyze the conversation history and the immediate context. Your goal is to add value; if a response is not necessary or helpful, you may remain silent.\n</ResponseStrategy>",
+    SELECTIVE_ENGAGEMENT: "\n<ResponseStrategy>\nYou must only respond when you can provide a valuable, relevant, and substantive contribution to the conversation. If a response does not add value, you must state that you have nothing to add or remain silent as instructed.\n</ResponseStrategy>",
+    TOOL_DRIVEN: "\n<ResponseStrategy>\nYour first priority is to use your available tools to gather the most current and accurate information before formulating a response. Do not answer from memory if a tool can provide a more reliable answer.\n</ResponseStrategy>"
 };
 
 /**
  * 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>"
+ */ var TONES = {
+    EMPATHETIC: "\n<Tone>\nYou must adopt a warm, understanding, and supportive tone. Acknowledge the user's feelings and demonstrate active listening.\n</Tone>",
+    HUMOROUS: "\n<Tone>\nYou should employ light-hearted humor, wit, and cleverness. Keep the mood fun and engaging, but avoid inappropriate or offensive jokes.\n</Tone>",
+    NEUTRAL: "\n<Tone>\nYou must maintain an impartial, objective, and straightforward tone. Avoid all emotional language and stick to the facts.\n</Tone>",
+    PROFESSIONAL: "\n<Tone>\nYou must use a formal, respectful, and clear tone. Structure 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>"
+    CONCISE: "\n<Verbosity>\nYou must provide brief, to-the-point answers. Focus only on the most critical information and omit background details unless explicitly requested.\n</Verbosity>",
+    DETAILED: "\n<Verbosity>\nYou must offer comprehensive and thorough responses. Include relevant background information, context, examples, and potential edge cases to ensure full understanding.\n</Verbosity>",
+    NORMAL: "\n<Verbosity>\nYou should provide a balanced level of detail, sufficient for a clear understanding without being overwhelming or too brief.\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,
+     * A fun and engaging community animator for platforms like Discord.
+     */ COMMUNITY_ANIMATOR: [
+        FOUNDATIONS.HARM_PREVENTION,
+        PERSONAS.COMMUNITY_ANIMATOR,
+        DOMAINS.GENERAL,
+        TONES.HUMOROUS,
         VERBOSITY.NORMAL,
-        FORMAT.MARKDOWN,
-        AGENT_LOGIC.ALWAYS_RESPOND,
-        AGENT_SKILLS.CREATIVE_IDEATION
+        RESPONSE.CONTEXTUAL_ENGAGEMENT
     ],
     /**
-     * A fun and engaging community animator for platforms like Discord.
-     */ DISCORD_COMMUNITY_ANIMATOR: [
-        DIRECTIVES.BE_SAFE,
-        PERSONA.COMMUNITY_ANIMATOR,
-        DOMAIN.GENERAL,
-        TONE.HUMOROUS,
+     * A creative partner for brainstorming and ideation.
+     */ CREATIVE_BRAINSTORMER: [
+        FOUNDATIONS.ETHICAL_CONDUCT,
+        PERSONAS.CREATIVE_PARTNER,
+        DOMAINS.GENERAL,
+        TONES.HUMOROUS,
         VERBOSITY.NORMAL,
-        FORMAT.MARKDOWN,
-        AGENT_LOGIC.ALWAYS_RESPOND,
-        AGENT_SKILLS.CREATIVE_IDEATION
+        RESPONSE.ALWAYS_ENGAGE
     ],
     /**
      * 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,
+        FOUNDATIONS.HARM_PREVENTION,
+        FOUNDATIONS.ETHICAL_CONDUCT,
+        PERSONAS.SUPPORT_AGENT,
+        DOMAINS.GENERAL,
+        TONES.EMPATHETIC,
         VERBOSITY.NORMAL,
-        FORMAT.STEP_BY_STEP,
-        AGENT_LOGIC.ALWAYS_RESPOND,
-        AGENT_SKILLS.PROBLEM_SOLVING
+        FORMATS.STEP_BY_STEP,
+        RESPONSE.ALWAYS_ENGAGE
     ]
 };
 
 var PROMPTS = {
-    AGENT_LOGIC: AGENT_LOGIC,
-    AGENT_SKILLS: AGENT_SKILLS,
-    DIRECTIVES: DIRECTIVES,
-    DOMAIN: DOMAIN,
-    FORMAT: FORMAT,
-    LANGUAGE: LANGUAGE,
-    PERSONA: PERSONA,
+    DOMAINS: DOMAINS,
+    FORMATS: FORMATS,
+    FOUNDATIONS: FOUNDATIONS,
+    LANGUAGES: LANGUAGES,
+    PERSONAS: PERSONAS,
     PRESETS: PRESETS,
-    TONE: TONE,
-    VERBOSITY: VERBOSITY
+    RESPONSE_STRATEGIES: RESPONSE,
+    TONES: TONES,
+    VERBOSITY_LEVELS: VERBOSITY
 };
 
 function _class_call_check$2(instance, Constructor) {
@@ -1456,6 +1714,7 @@ exports.AIResponseParser = AIResponseParser;
 exports.ChatAgentAdapter = ChatAgentAdapter;
 exports.OpenRouterAdapter = OpenRouterModelAdapter;
 exports.PROMPTS = PROMPTS;
+exports.QueryAgentAdapter = QueryAgentAdapter;
 exports.SafeToolAdapter = SafeToolAdapter;
 exports.SystemPromptAdapter = SystemPromptAdapter;
 exports.UserPromptAdapter = UserPromptAdapter;