@alquimia-ai/tools 1.0.1 → 1.0.2

package/dist/index.mjs

@@ -1,2336 +1,1202 @@
 // src/button.tsx
-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 _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
-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 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 _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(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
+import { jsx } from "react/jsx-runtime";
+var Button = ({ children, className, appName }) => {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      className,
+      onClick: () => alert(`Hello from your ${appName} app!`),
+      children
     }
-}
-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);
+  );
+};
+
+// src/card.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function Card({
+  className,
+  title,
+  children,
+  href
+}) {
+  return /* @__PURE__ */ jsxs(
+    "a",
+    {
+      className,
+      href: `${href}?utm_source=create-turbo&utm_medium=basic&utm_campaign=create-turbo"`,
+      rel: "noopener noreferrer",
+      target: "_blank",
+      children: [
+        /* @__PURE__ */ jsxs("h2", { children: [
+          title,
+          " ",
+          /* @__PURE__ */ jsx2("span", { children: "->" })
+        ] }),
+        /* @__PURE__ */ jsx2("p", { children })
+      ]
     }
+  );
 }
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    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;
+
+// src/code.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function Code({
+  children,
+  className
+}) {
+  return /* @__PURE__ */ jsx3("code", { className, children });
 }
-function _get_prototype_of(o) {
-    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
+
+// src/sdk/alquimia-sdk.ts
+import axios from "axios";
+var AlquimiaSDK = class {
+  constructor(config, enforceCharacterization = true) {
+    this.conversationId = null;
+    this.sessionId = null;
+    this.streamId = null;
+    this.tools = [];
+    this.extraData = {};
+    this.forceProfile = {};
+    this.config = config;
+    this.enforceCharacterization = enforceCharacterization;
+    this.axiosInstance = axios.create();
+    this.axiosInstance.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error.response?.status) {
+          if (this.loggerProvider) {
+            await this.loggerProvider.logError(
+              "Server Error",
+              error,
+              {
+                url: error.config.url,
+                method: error.config.method,
+                data: error.config.data,
+                status: error.response.status,
+                responseData: error.response.data
+              }
+            );
+          }
+        }
+        return Promise.reject(error);
+      }
+    );
+    this.textToSpeech = this.textToSpeech.bind(this);
+    this.speechToText = this.speechToText.bind(this);
+  }
+  static configure(apiKey, inferUrl, streamUrl, assistantId) {
+    return {
+      apiKey,
+      chatUrl: `${inferUrl}/chat/${assistantId}`,
+      streamUrl: `${streamUrl}/${assistantId}`,
+      assistantId
     };
-    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");
+  }
+  widthConversationId(conversationId) {
+    this.conversationId = conversationId;
+    return this;
+  }
+  withWhisperProvider(provider) {
+    this.whisperProvider = provider;
+    return this;
+  }
+  withStableDiffusionProvider(provider) {
+    this.stableDiffusionProvider = provider;
+    return this;
+  }
+  withAnalyzeCharacterizationProvider(provider) {
+    this.analyzeCharacterizationProvider = provider;
+    return this;
+  }
+  withRatingsProvider(provider) {
+    this.ratingsProvider = provider;
+    return this;
+  }
+  withLoggerProvider(provider) {
+    this.loggerProvider = provider;
+    return this;
+  }
+  getEnforceCharacterization() {
+    return this.enforceCharacterization ?? true;
+  }
+  withTools(tools) {
+    this.tools = tools;
+    return this;
+  }
+  withExtraData(extraData) {
+    this.extraData = extraData;
+    return this;
+  }
+  withForceProfile(forceProfile) {
+    this.forceProfile = forceProfile;
+    return this;
+  }
+  textToSpeech(text) {
+    if (!this.whisperProvider) {
+      throw new Error("Whisper provider not initialized");
     }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _set_prototype_of(subClass, superClass);
-}
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
+    return this.whisperProvider.textToSpeech(text);
+  }
+  speechToText(audio) {
+    if (!this.whisperProvider) {
+      throw new Error("Whisper provider not initialized");
     }
-}
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-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 this.whisperProvider.speechToText(audio);
+  }
+  async sendMessage(query, traceParent) {
+    if (!this.conversationId) {
+      throw new Error("Conversation not initialized");
     }
-    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 _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-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(target, key, source[key]);
-        });
+    const initMessage = {
+      query,
+      session_id: this.conversationId,
+      tools: this.tools,
+      extra_data: this.extraData,
+      force_profile: this.forceProfile
+    };
+    const result = (await this.axiosInstance.post(this.config.chatUrl, initMessage, {
+      headers: {
+        "Content-Type": "application/json",
+        "x-trace-parent": traceParent || ""
+      }
+    })).data;
+    this.streamId = result.data.stream_id;
+    return this;
+  }
+  async generateImage(query) {
+    if (!this.stableDiffusionProvider) {
+      throw new Error("Stable Diffusion provider not initialized");
     }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) {
-            symbols = symbols.filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-            });
-        }
-        keys.push.apply(keys, symbols);
+    return this.stableDiffusionProvider.generateImage(query);
+  }
+  async analyzeCharacterization(text) {
+    if (!this.analyzeCharacterizationProvider) {
+      throw new Error("analyze characterization provider not initialized");
     }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
+    return this.analyzeCharacterizationProvider.analyzeCharacterization(text);
+  }
+  async rate(data) {
+    if (!this.ratingsProvider) {
+      throw new Error("ratings provider not initialized");
     }
-    return target;
-}
-function _possible_constructor_return(self, call) {
-    if (call && (_type_of(call) === "object" || typeof call === "function")) {
-        return call;
+    return this.ratingsProvider.rate(data);
+  }
+  async logInfo(message, data) {
+    if (!this.loggerProvider) {
+      throw new Error("logger provider not initialized");
     }
-    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 _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 _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
-function _type_of(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);
-}
-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;
-    })();
-}
-function _ts_generator(thisArg, body) {
-    var f, y, t, g, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    };
-    return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-        return this;
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
+    return this.loggerProvider.logInfo(message, data);
+  }
+  async logError(message, error, data) {
+    if (!this.loggerProvider) {
+      throw new Error("logger provider not initialized");
     }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(_)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
-        };
-    }
-}
-var Button = function(param) {
-    var children = param.children, className = param.className, appName = param.appName;
-    return /* @__PURE__ */ React.createElement("button", {
-        className: className,
-        onClick: function() {
-            return alert("Hello from your ".concat(appName, " app!"));
-        }
-    }, children);
+    return this.loggerProvider.logError(message, error, data);
+  }
+  getUrlStream() {
+    return `${this.config.streamUrl}/${this.streamId}`;
+  }
 };
-// src/card.tsx
-function Card(param) {
-    var className = param.className, title = param.title, children = param.children, href = param.href;
-    return /* @__PURE__ */ React.createElement("a", {
-        className: className,
-        href: "".concat(href, '?utm_source=create-turbo&utm_medium=basic&utm_campaign=create-turbo"'),
-        rel: "noopener noreferrer",
-        target: "_blank"
-    }, /* @__PURE__ */ React.createElement("h2", null, title, " ", /* @__PURE__ */ React.createElement("span", null, "->")), /* @__PURE__ */ React.createElement("p", null, children));
-}
-// src/code.tsx
-function Code(param) {
-    var children = param.children, className = param.className;
-    return /* @__PURE__ */ React.createElement("code", {
-        className: className
-    }, children);
-}
-// src/sdk/alquimia-sdk.ts
-import axios from "axios";
-var AlquimiaSDK = /*#__PURE__*/ function() {
-    "use strict";
-    function AlquimiaSDK(config) {
-        var enforceCharacterization = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
-        _class_call_check(this, AlquimiaSDK);
-        var _this = this;
-        this.conversationId = null;
-        this.sessionId = null;
-        this.streamId = null;
-        this.tools = [];
-        this.extraData = {};
-        this.forceProfile = {};
-        this.config = config;
-        this.enforceCharacterization = enforceCharacterization;
-        this.axiosInstance = axios.create();
-        this.axiosInstance.interceptors.response.use(function(response) {
-            return response;
-        }, /*#__PURE__*/ function() {
-            var _ref = _async_to_generator(function(error) {
-                var _error_response;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            if (!((_error_response = error.response) === null || _error_response === void 0 ? void 0 : _error_response.status)) return [
-                                3,
-                                2
-                            ];
-                            if (!_this.loggerProvider) return [
-                                3,
-                                2
-                            ];
-                            return [
-                                4,
-                                _this.loggerProvider.logError("Server Error", error, {
-                                    url: error.config.url,
-                                    method: error.config.method,
-                                    data: error.config.data,
-                                    status: error.response.status,
-                                    responseData: error.response.data
-                                })
-                            ];
-                        case 1:
-                            _state.sent();
-                            _state.label = 2;
-                        case 2:
-                            return [
-                                2,
-                                Promise.reject(error)
-                            ];
-                    }
-                });
-            });
-            return function(error) {
-                return _ref.apply(this, arguments);
-            };
-        }());
-        this.textToSpeech = this.textToSpeech.bind(this);
-        this.speechToText = this.speechToText.bind(this);
-    }
-    _create_class(AlquimiaSDK, [
-        {
-            key: "widthConversationId",
-            value: function widthConversationId(conversationId) {
-                this.conversationId = conversationId;
-                return this;
-            }
-        },
-        {
-            key: "withWhisperProvider",
-            value: function withWhisperProvider(provider) {
-                this.whisperProvider = provider;
-                return this;
-            }
-        },
-        {
-            key: "withStableDiffusionProvider",
-            value: function withStableDiffusionProvider(provider) {
-                this.stableDiffusionProvider = provider;
-                return this;
-            }
-        },
-        {
-            key: "withAnalyzeCharacterizationProvider",
-            value: function withAnalyzeCharacterizationProvider(provider) {
-                this.analyzeCharacterizationProvider = provider;
-                return this;
-            }
-        },
-        {
-            key: "withRatingsProvider",
-            value: function withRatingsProvider(provider) {
-                this.ratingsProvider = provider;
-                return this;
-            }
-        },
-        {
-            key: "withLoggerProvider",
-            value: function withLoggerProvider(provider) {
-                this.loggerProvider = provider;
-                return this;
-            }
-        },
-        {
-            key: "getEnforceCharacterization",
-            value: function getEnforceCharacterization() {
-                var _this_enforceCharacterization;
-                return (_this_enforceCharacterization = this.enforceCharacterization) !== null && _this_enforceCharacterization !== void 0 ? _this_enforceCharacterization : true;
-            }
-        },
-        {
-            key: "withTools",
-            value: function withTools(tools) {
-                this.tools = tools;
-                return this;
-            }
-        },
-        {
-            key: "withExtraData",
-            value: function withExtraData(extraData) {
-                this.extraData = extraData;
-                return this;
-            }
-        },
-        {
-            key: "withForceProfile",
-            value: function withForceProfile(forceProfile) {
-                this.forceProfile = forceProfile;
-                return this;
-            }
-        },
-        {
-            key: "textToSpeech",
-            value: function textToSpeech(text) {
-                if (!this.whisperProvider) {
-                    throw new Error("Whisper provider not initialized");
-                }
-                return this.whisperProvider.textToSpeech(text);
-            }
-        },
-        {
-            key: "speechToText",
-            value: function speechToText(audio) {
-                if (!this.whisperProvider) {
-                    throw new Error("Whisper provider not initialized");
-                }
-                return this.whisperProvider.speechToText(audio);
-            }
-        },
-        {
-            key: "sendMessage",
-            value: function sendMessage(query, traceParent) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var initMessage, result;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                if (!_this.conversationId) {
-                                    throw new Error("Conversation not initialized");
-                                }
-                                initMessage = {
-                                    query: query,
-                                    session_id: _this.conversationId,
-                                    tools: _this.tools,
-                                    extra_data: _this.extraData,
-                                    force_profile: _this.forceProfile
-                                };
-                                return [
-                                    4,
-                                    _this.axiosInstance.post(_this.config.chatUrl, initMessage, {
-                                        headers: {
-                                            "Content-Type": "application/json",
-                                            "x-trace-parent": traceParent || ""
-                                        }
-                                    })
-                                ];
-                            case 1:
-                                result = _state.sent().data;
-                                _this.streamId = result.data.stream_id;
-                                return [
-                                    2,
-                                    _this
-                                ];
-                        }
-                    });
-                })();
-            }
-        },
-        {
-            key: "generateImage",
-            value: function generateImage(query) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        if (!_this.stableDiffusionProvider) {
-                            throw new Error("Stable Diffusion provider not initialized");
-                        }
-                        return [
-                            2,
-                            _this.stableDiffusionProvider.generateImage(query)
-                        ];
-                    });
-                })();
-            }
-        },
-        {
-            key: "analyzeCharacterization",
-            value: function analyzeCharacterization(text) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        if (!_this.analyzeCharacterizationProvider) {
-                            throw new Error("analyze characterization provider not initialized");
-                        }
-                        return [
-                            2,
-                            _this.analyzeCharacterizationProvider.analyzeCharacterization(text)
-                        ];
-                    });
-                })();
-            }
-        },
-        {
-            key: "rate",
-            value: function rate(data) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        if (!_this.ratingsProvider) {
-                            throw new Error("ratings provider not initialized");
-                        }
-                        return [
-                            2,
-                            _this.ratingsProvider.rate(data)
-                        ];
-                    });
-                })();
-            }
-        },
-        {
-            key: "logInfo",
-            value: function logInfo(message, data) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        if (!_this.loggerProvider) {
-                            throw new Error("logger provider not initialized");
-                        }
-                        return [
-                            2,
-                            _this.loggerProvider.logInfo(message, data)
-                        ];
-                    });
-                })();
-            }
-        },
-        {
-            key: "logError",
-            value: function logError(message, error, data) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        if (!_this.loggerProvider) {
-                            throw new Error("logger provider not initialized");
-                        }
-                        return [
-                            2,
-                            _this.loggerProvider.logError(message, error, data)
-                        ];
-                    });
-                })();
-            }
-        },
-        {
-            key: "getUrlStream",
-            value: function getUrlStream() {
-                return "".concat(this.config.streamUrl, "/").concat(this.streamId);
-            }
-        }
-    ], [
-        {
-            key: "configure",
-            value: function configure(apiKey, inferUrl, streamUrl, assistantId) {
-                return {
-                    apiKey: apiKey,
-                    chatUrl: "".concat(inferUrl, "/chat/").concat(assistantId),
-                    streamUrl: "".concat(streamUrl, "/").concat(assistantId),
-                    assistantId: assistantId
-                };
-            }
-        }
-    ]);
-    return AlquimiaSDK;
-}();
 var alquimia_sdk_default = AlquimiaSDK;
+
 // src/sdk/providers/providers.ts
-var GenerativeProvider = function GenerativeProvider(config) {
-    "use strict";
-    _class_call_check(this, GenerativeProvider);
+var GenerativeProvider = class {
+  constructor(config) {
     this.config = config;
+  }
 };
-var WhisperProvider = function WhisperProvider(config) {
-    "use strict";
-    _class_call_check(this, WhisperProvider);
+var WhisperProvider = class {
+  constructor(config) {
     this.config = config;
+  }
 };
-var StableDiffusionProvider = function StableDiffusionProvider(config) {
-    "use strict";
-    _class_call_check(this, StableDiffusionProvider);
+var StableDiffusionProvider = class {
+  constructor(config) {
     this.config = config;
+  }
 };
-var CharacterizationProvider = function CharacterizationProvider(config) {
-    "use strict";
-    _class_call_check(this, CharacterizationProvider);
+var CharacterizationProvider = class {
+  constructor(config) {
     this.config = config;
+  }
 };
-var RatingsProvider = function RatingsProvider(config) {
-    "use strict";
-    _class_call_check(this, RatingsProvider);
+var RatingsProvider = class {
+  constructor(config) {
     this.config = config;
+  }
 };
-var LoggerProvider = function LoggerProvider(config) {
-    "use strict";
-    _class_call_check(this, LoggerProvider);
+var LoggerProvider = class {
+  constructor(config) {
     this.config = config;
+  }
 };
+
 // src/sdk/providers/alquimia.ts
 import axios2 from "axios";
-var AlquimiaWhisperProvider = /*#__PURE__*/ function(WhisperProvider) {
-    "use strict";
-    _inherits(AlquimiaWhisperProvider, WhisperProvider);
-    function AlquimiaWhisperProvider(config) {
-        _class_call_check(this, AlquimiaWhisperProvider);
-        return _call_super(this, AlquimiaWhisperProvider, [
-            config
-        ]);
-    }
-    _create_class(AlquimiaWhisperProvider, [
+var AlquimiaWhisperProvider = class extends WhisperProvider {
+  constructor(config) {
+    super(config);
+  }
+  async textToSpeech(text) {
+    const axiosClient = axios2.create({
+      baseURL: this.config.baseURL
+    });
+    try {
+      const response = await axiosClient.post(
+        this.config.ttsRoute,
         {
-            key: "textToSpeech",
-            value: function textToSpeech(text) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var axiosClient, response, error;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                axiosClient = axios2.create({
-                                    baseURL: _this.config.baseURL
-                                });
-                                _state.label = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    3,
-                                    ,
-                                    4
-                                ]);
-                                return [
-                                    4,
-                                    axiosClient.post(_this.config.ttsRoute, {
-                                        text: text
-                                    }, {
-                                        responseType: "blob"
-                                    })
-                                ];
-                            case 2:
-                                response = _state.sent();
-                                return [
-                                    2,
-                                    response.data
-                                ];
-                            case 3:
-                                error = _state.sent();
-                                console.error("Error converting text to speech:", error);
-                                throw error;
-                            case 4:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                })();
-            }
+          text
         },
-        {
-            key: "speechToText",
-            value: function speechToText(audio) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var axiosClient, response, error;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                axiosClient = axios2.create({
-                                    baseURL: _this.config.baseURL
-                                });
-                                _state.label = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    3,
-                                    ,
-                                    4
-                                ]);
-                                return [
-                                    4,
-                                    axiosClient.post(_this.config.sttRoute, {
-                                        audio: audio
-                                    })
-                                ];
-                            case 2:
-                                response = _state.sent();
-                                return [
-                                    2,
-                                    response.data
-                                ];
-                            case 3:
-                                error = _state.sent();
-                                console.error("Error converting speech to text:", error);
-                                throw error;
-                            case 4:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                })();
-            }
+        { responseType: "blob" }
+      );
+      return response.data;
+    } catch (error) {
+      console.error("Error converting text to speech:", error);
+      throw error;
+    }
+  }
+  async speechToText(audio) {
+    const axiosClient = axios2.create({
+      baseURL: this.config.baseURL
+    });
+    try {
+      const response = await axiosClient.post(this.config.sttRoute, {
+        audio
+      });
+      return response.data;
+    } catch (error) {
+      console.error("Error converting speech to text:", error);
+      throw error;
+    }
+  }
+};
+var AlquimiaRatingsProvider = class extends RatingsProvider {
+  constructor(config) {
+    super(config);
+  }
+  async rate(data) {
+    const path = `${this.config.baseUrl}${this.config.route}`;
+    try {
+      let response;
+      const headers = {
+        Authorization: `Bearer ${this.config.token}`,
+        "Content-Type": "application/json",
+        ...this.config.headers || {}
+      };
+      response = await axios2.post(`${path}`, data, { headers });
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      if (axios2.isAxiosError(error)) {
+        return {
+          success: false,
+          error: {
+            message: error.message,
+            response: {
+              status: error.response?.status,
+              data: error.response?.data
+            },
+            details: error.response?.data
+          }
+        };
+      }
+      return {
+        success: false,
+        error: {
+          message: error instanceof Error ? error.message : "Unknown error occurred",
+          response: {
+            status: 500
+          }
         }
-    ]);
-    return AlquimiaWhisperProvider;
-}(WhisperProvider);
-var AlquimiaRatingsProvider = /*#__PURE__*/ function(RatingsProvider) {
-    "use strict";
-    _inherits(AlquimiaRatingsProvider, RatingsProvider);
-    function AlquimiaRatingsProvider(config) {
-        _class_call_check(this, AlquimiaRatingsProvider);
-        return _call_super(this, AlquimiaRatingsProvider, [
-            config
-        ]);
+      };
     }
-    _create_class(AlquimiaRatingsProvider, [
+  }
+};
+
+// src/utils/utils.ts
+function generateTranslatePrompt(text) {
+  const prompt = `
+        Arrange the following text according to the given object structure and return it as plain json, values summarized to one word, no formatting:
         {
-            key: "rate",
-            value: function rate(data) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var path, response, headers, error, _error_response, _error_response1, _error_response2;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                path = "".concat(_this.config.baseUrl).concat(_this.config.route);
-                                _state.label = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    3,
-                                    ,
-                                    4
-                                ]);
-                                headers = _object_spread({
-                                    Authorization: "Bearer ".concat(_this.config.token),
-                                    "Content-Type": "application/json"
-                                }, _this.config.headers || {});
-                                return [
-                                    4,
-                                    axios2.post("".concat(path), data, {
-                                        headers: headers
-                                    })
-                                ];
-                            case 2:
-                                response = _state.sent();
-                                return [
-                                    2,
-                                    {
-                                        success: true,
-                                        data: response.data
-                                    }
-                                ];
-                            case 3:
-                                error = _state.sent();
-                                if (axios2.isAxiosError(error)) {
-                                    ;
-                                    return [
-                                        2,
-                                        {
-                                            success: false,
-                                            error: {
-                                                message: error.message,
-                                                response: {
-                                                    status: (_error_response = error.response) === null || _error_response === void 0 ? void 0 : _error_response.status,
-                                                    data: (_error_response1 = error.response) === null || _error_response1 === void 0 ? void 0 : _error_response1.data
-                                                },
-                                                details: (_error_response2 = error.response) === null || _error_response2 === void 0 ? void 0 : _error_response2.data
-                                            }
-                                        }
-                                    ];
-                                }
-                                return [
-                                    2,
-                                    {
-                                        success: false,
-                                        error: {
-                                            message: _instanceof(error, Error) ? error.message : "Unknown error occurred",
-                                            response: {
-                                                status: 500
-                                            }
-                                        }
-                                    }
-                                ];
-                            case 4:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                })();
+            restrictions: {
+                value: [''],
+                description: 'Restrictions to certain foods'
+            },
+            alergies: {
+                value: [''],
+                description: 'Alergies to certain foods'
+            },
+            wine_preference: {
+                value: [''],
+                description: 'Preferences for the wine'
+            },
+            meal_preference: {
+                value: [''],
+                description: 'Preferences for the meal'
             }
         }
-    ]);
-    return AlquimiaRatingsProvider;
-}(RatingsProvider);
-// src/utils/utils.ts
-function generateTranslatePrompt(text) {
-    var prompt = "\n        Arrange the following text according to the given object structure and return it as plain json, values summarized to one word, no formatting:\n        {\n            restrictions: {\n                value: [''],\n                description: 'Restrictions to certain foods'\n            },\n            alergies: {\n                value: [''],\n                description: 'Alergies to certain foods'\n            },\n            wine_preference: {\n                value: [''],\n                description: 'Preferences for the wine'\n            },\n            meal_preference: {\n                value: [''],\n                description: 'Preferences for the meal'\n            }\n        }\n\n        Text: \"".concat(text, '"\n\n        Output:\n    ');
-    return prompt;
+
+        Text: "${text}"
+
+        Output:
+    `;
+  return prompt;
 }
 function getCookies(name) {
-    var _parts_pop;
-    if (typeof document === "undefined") return void 0;
-    var value = "; ".concat(document.cookie);
-    var parts = value.split("; ".concat(name, "="));
-    if (parts.length === 2) return (_parts_pop = parts.pop()) === null || _parts_pop === void 0 ? void 0 : _parts_pop.split(";").shift();
+  if (typeof document === "undefined") return void 0;
+  const value = `; ${document.cookie}`;
+  const parts = value.split(`; ${name}=`);
+  if (parts.length === 2) return parts.pop()?.split(";").shift();
 }
 function generateHeaders(config) {
-    var headers = {
-        "Content-Type": "application/json"
-    };
-    if (config.token) {
-        headers["Authorization"] = "Bearer ".concat(config.token);
-    }
-    if (config.headers) {
-        Object.entries(config.headers).forEach(function(param) {
-            var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
-            headers[key] = value;
-        });
-    }
-    return headers;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.token) {
+    headers["Authorization"] = `Bearer ${config.token}`;
+  }
+  if (config.headers) {
+    Object.entries(config.headers).forEach(([key, value]) => {
+      headers[key] = value;
+    });
+  }
+  return headers;
 }
 function isTextContent(buffer) {
-    try {
-        var text = new TextDecoder().decode(buffer);
-        return /^[\w\#\-\*]/.test(text.trim());
-    } catch (e) {
-        return false;
-    }
+  try {
+    const text = new TextDecoder().decode(buffer);
+    return /^[\w\#\-\*]/.test(text.trim());
+  } catch {
+    return false;
+  }
 }
 function getQueryParam(param) {
-    if (typeof window !== "undefined") {
-        var urlParams = new URLSearchParams(window.location.search);
-        return urlParams.get(param);
-    }
-    return null;
+  if (typeof window !== "undefined") {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get(param);
+  }
+  return null;
 }
 function defineAssistantId(defaultId) {
-    if (typeof window !== "undefined" && window.location.pathname === "/") {
-        var queryAssistantId = getQueryParam("talkwith");
-        if (queryAssistantId) {
-            localStorage.setItem("assistantId", queryAssistantId);
-            return queryAssistantId;
-        }
-        var storedAssistantId = localStorage.getItem("assistantId");
-        return storedAssistantId || defaultId;
+  if (typeof window !== "undefined" && window.location.pathname === "/") {
+    const queryAssistantId = getQueryParam("talkwith");
+    if (queryAssistantId) {
+      localStorage.setItem("assistantId", queryAssistantId);
+      return queryAssistantId;
     }
-    return defaultId;
+    const storedAssistantId = localStorage.getItem("assistantId");
+    return storedAssistantId || defaultId;
+  }
+  return defaultId;
 }
 function formatTimeWithUnit(timeMs) {
-    if (timeMs >= 1e3) {
-        return "".concat((timeMs / 1e3).toFixed(1), "s");
-    }
-    return "".concat(Math.round(timeMs), "ms");
+  if (timeMs >= 1e3) {
+    return `${(timeMs / 1e3).toFixed(1)}s`;
+  }
+  return `${Math.round(timeMs)}ms`;
 }
 function serializeAxiosError(error) {
-    if (_instanceof(error, Error)) {
-        var customError = error;
-        return {
-            message: customError === null || customError === void 0 ? void 0 : customError.message,
-            name: customError === null || customError === void 0 ? void 0 : customError.name,
-            stack: customError === null || customError === void 0 ? void 0 : customError.stack,
-            code: customError === null || customError === void 0 ? void 0 : customError.code,
-            status: customError === null || customError === void 0 ? void 0 : customError.status
-        };
-    }
+  if (error instanceof Error) {
+    const customError = error;
     return {
-        message: String(error),
-        name: "Unknown Error"
+      message: customError?.message,
+      name: customError?.name,
+      stack: customError?.stack,
+      code: customError?.code,
+      status: customError?.status
     };
+  }
+  return {
+    message: String(error),
+    name: "Unknown Error"
+  };
 }
 function parseConversationsMapCookie(cookieValue) {
-    try {
-        var decodedValue = decodeURIComponent(cookieValue);
-        return JSON.parse(decodedValue);
-    } catch (e) {
-        console.error("Error parsing conversations cookie:", e);
-        return {};
-    }
+  try {
+    const decodedValue = decodeURIComponent(cookieValue);
+    return JSON.parse(decodedValue);
+  } catch (e) {
+    console.error("Error parsing conversations cookie:", e);
+    return {};
+  }
 }
 function getTopicSessionId(topicId) {
-    var conversationsStr = getCookies("alquimia-sessions") || "{}";
-    if (!conversationsStr) {
-        var sessionCookie = getCookies("alquimia-session");
-        return sessionCookie || "";
-    }
-    var conversationsMap = parseConversationsMapCookie(conversationsStr);
-    return conversationsMap[topicId] || "";
+  const conversationsStr = getCookies("alquimia-sessions") || "{}";
+  if (!conversationsStr) {
+    const sessionCookie = getCookies("alquimia-session");
+    return sessionCookie || "";
+  }
+  const conversationsMap = parseConversationsMapCookie(conversationsStr);
+  return conversationsMap[topicId] || "";
 }
 function createMessageId() {
-    return Math.floor(Math.random() * 1e6).toString();
+  return Math.floor(Math.random() * 1e6).toString();
 }
+
 // src/sdk/providers/openai.ts
 import OpenAI from "openai";
-var OpenAIWhisperProvider = /*#__PURE__*/ function(WhisperProvider) {
-    "use strict";
-    _inherits(OpenAIWhisperProvider, WhisperProvider);
-    function OpenAIWhisperProvider() {
-        _class_call_check(this, OpenAIWhisperProvider);
-        return _call_super(this, OpenAIWhisperProvider, arguments);
-    }
-    _create_class(OpenAIWhisperProvider, [
-        {
-            key: "textToSpeech",
-            value: function textToSpeech(text) {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        return [
-                            2,
-                            new Blob()
-                        ];
-                    });
-                })();
-            }
-        },
-        {
-            key: "speechToText",
-            value: function speechToText(audio) {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        return [
-                            2,
-                            ""
-                        ];
-                    });
-                })();
-            }
-        }
-    ]);
-    return OpenAIWhisperProvider;
-}(WhisperProvider);
-var OpenAIAnalyzeCharProvider = /*#__PURE__*/ function(CharacterizationProvider) {
-    "use strict";
-    _inherits(OpenAIAnalyzeCharProvider, CharacterizationProvider);
-    function OpenAIAnalyzeCharProvider(config) {
-        _class_call_check(this, OpenAIAnalyzeCharProvider);
-        var _this;
-        _this = _call_super(this, OpenAIAnalyzeCharProvider, [
-            config
-        ]);
-        _this.client = new OpenAI({
-            apiKey: config.apiKey
-        });
-        return _this;
-    }
-    _create_class(OpenAIAnalyzeCharProvider, [
-        {
-            key: "analyzeCharacterization",
-            value: function analyzeCharacterization(text) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var prompt, response, arrangedText, arrangedObject;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                prompt = generateTranslatePrompt(text);
-                                return [
-                                    4,
-                                    _this.client.chat.completions.create({
-                                        model: "gpt-4o-mini",
-                                        messages: [
-                                            {
-                                                role: "system",
-                                                content: "You are a helpful assistant."
-                                            },
-                                            {
-                                                role: "user",
-                                                content: prompt
-                                            }
-                                        ],
-                                        max_tokens: 150,
-                                        temperature: 0.7
-                                    })
-                                ];
-                            case 1:
-                                response = _state.sent();
-                                arrangedText = response.choices[0].message.content.trim();
-                                try {
-                                    arrangedObject = JSON.parse(arrangedText);
-                                    return [
-                                        2,
-                                        arrangedObject
-                                    ];
-                                } catch (error) {
-                                    throw new Error("Failed to parse the response from OpenAI");
-                                }
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                })();
-            }
-        }
-    ]);
-    return OpenAIAnalyzeCharProvider;
-}(CharacterizationProvider);
-var OpenAIStableDiffusionProvider = /*#__PURE__*/ function(StableDiffusionProvider) {
-    "use strict";
-    _inherits(OpenAIStableDiffusionProvider, StableDiffusionProvider);
-    function OpenAIStableDiffusionProvider(config) {
-        _class_call_check(this, OpenAIStableDiffusionProvider);
-        var _this;
-        _this = _call_super(this, OpenAIStableDiffusionProvider, [
-            config
-        ]);
-        _this.client = new OpenAI({
-            apiKey: config.apiKey
-        });
-        return _this;
+var OpenAIWhisperProvider = class extends WhisperProvider {
+  async textToSpeech(text) {
+    return new Blob();
+  }
+  async speechToText(audio) {
+    return "";
+  }
+};
+var OpenAIAnalyzeCharProvider = class extends CharacterizationProvider {
+  constructor(config) {
+    super(config);
+    this.client = new OpenAI({
+      apiKey: config.apiKey
+    });
+  }
+  async analyzeCharacterization(text) {
+    const prompt = generateTranslatePrompt(text);
+    const response = await this.client.chat.completions.create({
+      model: "gpt-4o-mini",
+      messages: [
+        { role: "system", content: "You are a helpful assistant." },
+        { role: "user", content: prompt }
+      ],
+      max_tokens: 150,
+      temperature: 0.7
+    });
+    const arrangedText = response.choices[0].message.content.trim();
+    try {
+      const arrangedObject = JSON.parse(arrangedText);
+      return arrangedObject;
+    } catch (error) {
+      throw new Error("Failed to parse the response from OpenAI");
     }
-    _create_class(OpenAIStableDiffusionProvider, [
-        {
-            key: "generateImage",
-            value: function generateImage(query) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var response;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                return [
-                                    4,
-                                    _this.client.images.generate({
-                                        model: "dall-e-3",
-                                        prompt: query,
-                                        n: 1,
-                                        size: "1024x1024"
-                                    })
-                                ];
-                            case 1:
-                                response = _state.sent();
-                                return [
-                                    2,
-                                    response.data[0].url
-                                ];
-                        }
-                    });
-                })();
-            }
-        }
-    ]);
-    return OpenAIStableDiffusionProvider;
-}(StableDiffusionProvider);
+  }
+};
+var OpenAIStableDiffusionProvider = class extends StableDiffusionProvider {
+  constructor(config) {
+    super(config);
+    this.client = new OpenAI({
+      apiKey: config.apiKey
+    });
+  }
+  async generateImage(query) {
+    const response = await this.client.images.generate({
+      model: "dall-e-3",
+      prompt: query,
+      n: 1,
+      size: "1024x1024"
+    });
+    return response.data[0].url;
+  }
+};
+
 // src/sdk/providers/stability.ts
 import { Buffer } from "buffer";
 import axios3 from "axios";
-var StabilityProvider = /*#__PURE__*/ function(StableDiffusionProvider) {
-    "use strict";
-    _inherits(StabilityProvider, StableDiffusionProvider);
-    function StabilityProvider(config) {
-        _class_call_check(this, StabilityProvider);
-        return _call_super(this, StabilityProvider, [
-            config
-        ]);
-    }
-    _create_class(StabilityProvider, [
-        {
-            key: "generateImage",
-            value: function generateImage(query) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var payload, response, base64Image;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                payload = {
-                                    prompt: "query",
-                                    output_format: "webp"
-                                };
-                                return [
-                                    4,
-                                    axios3.postForm("https://api.stability.ai/v2beta/stable-image/generate/ultra", axios3.toFormData(payload, new FormData()), {
-                                        validateStatus: void 0,
-                                        responseType: "arraybuffer",
-                                        headers: {
-                                            Authorization: "Bearer ".concat(_this.config.apiKey),
-                                            Accept: "image/*"
-                                        }
-                                    })
-                                ];
-                            case 1:
-                                response = _state.sent();
-                                if (response.status === 200) {
-                                    base64Image = Buffer.from(response.data).toString("base64");
-                                    return [
-                                        2,
-                                        "data:image/webp;base64,".concat(base64Image)
-                                    ];
-                                } else {
-                                    throw new Error("".concat(response.status, ": ").concat(response.data.toString()));
-                                }
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                })();
-            }
+var StabilityProvider = class extends StableDiffusionProvider {
+  constructor(config) {
+    super(config);
+  }
+  async generateImage(query) {
+    const payload = {
+      prompt: "query",
+      output_format: "webp"
+    };
+    const response = await axios3.postForm(
+      `https://api.stability.ai/v2beta/stable-image/generate/ultra`,
+      axios3.toFormData(payload, new FormData()),
+      {
+        validateStatus: void 0,
+        responseType: "arraybuffer",
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          Accept: "image/*"
         }
-    ]);
-    return StabilityProvider;
-}(StableDiffusionProvider);
+      }
+    );
+    if (response.status === 200) {
+      const base64Image = Buffer.from(response.data).toString("base64");
+      return `data:image/webp;base64,${base64Image}`;
+    } else {
+      throw new Error(`${response.status}: ${response.data.toString()}`);
+    }
+  }
+};
+
 // src/sdk/providers/eleven-labs.ts
 import { ElevenLabsClient, ElevenLabs } from "elevenlabs";
 import axios4 from "axios";
 var requestSpecs = {
-    optimize_streaming_latency: ElevenLabs.OptimizeStreamingLatency.Zero,
-    output_format: ElevenLabs.OutputFormat.Mp344100128,
-    model_id: "eleven_multilingual_v1",
-    language: "es",
-    voice_settings: {
-        stability: 0.1,
-        similarity_boost: 0.15,
-        style: 0.2
-    }
+  optimize_streaming_latency: ElevenLabs.OptimizeStreamingLatency.Zero,
+  output_format: ElevenLabs.OutputFormat.Mp344100128,
+  model_id: "eleven_multilingual_v1",
+  language: "es",
+  voice_settings: {
+    stability: 0.1,
+    similarity_boost: 0.15,
+    style: 0.2
+  }
 };
-var ElevenLabsWhisperProvider = /*#__PURE__*/ function(WhisperProvider) {
-    "use strict";
-    _inherits(ElevenLabsWhisperProvider, WhisperProvider);
-    function ElevenLabsWhisperProvider(config) {
-        _class_call_check(this, ElevenLabsWhisperProvider);
-        var _this;
-        _this = _call_super(this, ElevenLabsWhisperProvider, [
-            config
-        ]);
-        _this.client = new ElevenLabsClient(config);
-        return _this;
-    }
-    _create_class(ElevenLabsWhisperProvider, [
+var ElevenLabsWhisperProvider = class extends WhisperProvider {
+  constructor(config) {
+    super(config);
+    this.client = new ElevenLabsClient(config);
+  }
+  async speechToText(audio) {
+    return "";
+  }
+  async textToSpeech(text) {
+    const axiosClient = axios4.create({
+      baseURL: this.config.baseURL,
+      headers: {
+        Accept: "audio/mpeg",
+        "Content-Type": "application/json",
+        "Xi-Api-Key": this.config.apiKey
+      }
+    });
+    try {
+      const response = await axiosClient.post(
+        `/v1/text-to-speech/${this.config.voiceId}`,
         {
-            key: "speechToText",
-            value: function speechToText(audio) {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        return [
-                            2,
-                            ""
-                        ];
-                    });
-                })();
-            }
+          text,
+          ...requestSpecs
         },
-        {
-            key: "textToSpeech",
-            value: function textToSpeech(text) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var axiosClient, response, error;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                axiosClient = axios4.create({
-                                    baseURL: _this.config.baseURL,
-                                    headers: {
-                                        Accept: "audio/mpeg",
-                                        "Content-Type": "application/json",
-                                        "Xi-Api-Key": _this.config.apiKey
-                                    }
-                                });
-                                _state.label = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    3,
-                                    ,
-                                    4
-                                ]);
-                                return [
-                                    4,
-                                    axiosClient.post("/v1/text-to-speech/".concat(_this.config.voiceId), _object_spread({
-                                        text: text
-                                    }, requestSpecs), {
-                                        responseType: "blob"
-                                    })
-                                ];
-                            case 2:
-                                response = _state.sent();
-                                return [
-                                    2,
-                                    response.data
-                                ];
-                            case 3:
-                                error = _state.sent();
-                                console.error("Error converting text to speech:", error);
-                                throw error;
-                            case 4:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                })();
-            }
-        }
-    ]);
-    return ElevenLabsWhisperProvider;
-}(WhisperProvider);
+        { responseType: "blob" }
+      );
+      return response.data;
+    } catch (error) {
+      console.error("Error converting text to speech:", error);
+      throw error;
+    }
+  }
+};
+
 // src/sdk/providers/elastic-search.ts
 import pino from "pino";
-var ElasticLoggerProvider = /*#__PURE__*/ function(LoggerProvider) {
-    "use strict";
-    _inherits(_ElasticLoggerProvider, LoggerProvider);
-    function _ElasticLoggerProvider(config) {
-        _class_call_check(this, _ElasticLoggerProvider);
-        var _this;
-        _this = _call_super(this, _ElasticLoggerProvider, [
-            config
-        ]);
-        _this.logger = console;
-        return _this;
-    }
-    _create_class(_ElasticLoggerProvider, [
-        {
-            key: "initialize",
-            value: function initialize(config) {
-                var _this = this;
-                return _async_to_generator(function() {
-                    var _ref, pinoElastic, streamToElastic;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                if (!(typeof window === "undefined")) return [
-                                    3,
-                                    2
-                                ];
-                                return [
-                                    4,
-                                    Promise.all([
-                                        import("pino-elasticsearch")
-                                    ])
-                                ];
-                            case 1:
-                                _ref = _sliced_to_array.apply(void 0, [
-                                    _state.sent(),
-                                    1
-                                ]), pinoElastic = _ref[0];
-                                streamToElastic = pinoElastic.default({
-                                    index: config.index || "logs-index",
-                                    node: config.endpoint,
-                                    esVersion: config.esVersion || 7,
-                                    flushBytes: config.flushBytes || 1e3,
-                                    auth: {
-                                        username: config.username || "",
-                                        password: config.password || ""
-                                    },
-                                    tls: {
-                                        rejectUnauthorized: false
-                                    },
-                                    op_type: "create"
-                                });
-                                streamToElastic.on("error", function(err) {
-                                    console.error("Elasticsearch stream error:", err);
-                                });
-                                streamToElastic.on("insertError", function(err) {
-                                    console.error("Elasticsearch insert error:", err);
-                                });
-                                streamToElastic.on("insert", function() {
-                                    console.log("Successfully sent log to Elasticsearch");
-                                });
-                                _this.logger = pino({
-                                    level: "info",
-                                    timestamp: function() {
-                                        return ',"time":"'.concat(/* @__PURE__ */ new Date().toISOString(), '"');
-                                    }
-                                }, streamToElastic);
-                                _state.label = 2;
-                            case 2:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                })();
-            }
+var ElasticLoggerProvider = class _ElasticLoggerProvider extends LoggerProvider {
+  constructor(config) {
+    super(config);
+    this.logger = console;
+  }
+  static async create(config) {
+    const provider = new _ElasticLoggerProvider(config);
+    await provider.initialize(config);
+    return provider;
+  }
+  async initialize(config) {
+    if (typeof window === "undefined") {
+      const [pinoElastic] = await Promise.all([
+        import("pino-elasticsearch")
+      ]);
+      const streamToElastic = pinoElastic.default({
+        index: config.index || "logs-index",
+        node: config.endpoint,
+        esVersion: config.esVersion || 7,
+        flushBytes: config.flushBytes || 1e3,
+        auth: {
+          username: config.username || "",
+          password: config.password || ""
         },
-        {
-            key: "logInfo",
-            value: function logInfo(message, data) {
-                this.logger.info(_object_spread({}, data), message);
-            }
+        tls: {
+          rejectUnauthorized: false
         },
-        {
-            key: "logError",
-            value: function logError(message, error, data) {
-                var errorDetails = {
-                    message: error.message,
-                    name: error.name,
-                    stack: error.stack
-                };
-                this.logger.error(_object_spread({
-                    error: error
-                }, data, errorDetails), message);
-            }
-        }
-    ], [
-        {
-            key: "create",
-            value: function create(config) {
-                return _async_to_generator(function() {
-                    var provider;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                provider = new _ElasticLoggerProvider(config);
-                                return [
-                                    4,
-                                    provider.initialize(config)
-                                ];
-                            case 1:
-                                _state.sent();
-                                return [
-                                    2,
-                                    provider
-                                ];
-                        }
-                    });
-                })();
-            }
-        }
-    ]);
-    return _ElasticLoggerProvider;
-}(LoggerProvider);
+        op_type: "create"
+      });
+      streamToElastic.on("error", (err) => {
+        console.error("Elasticsearch stream error:", err);
+      });
+      streamToElastic.on("insertError", (err) => {
+        console.error("Elasticsearch insert error:", err);
+      });
+      streamToElastic.on("insert", () => {
+        console.log("Successfully sent log to Elasticsearch");
+      });
+      this.logger = pino({
+        level: "info",
+        timestamp: () => `,"time":"${(/* @__PURE__ */ new Date()).toISOString()}"`
+      }, streamToElastic);
+    }
+  }
+  logInfo(message, data) {
+    this.logger.info({ ...data }, message);
+  }
+  logError(message, error, data) {
+    const errorDetails = {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+    this.logger.error({ error, ...data, ...errorDetails }, message);
+  }
+};
+
 // src/hooks/alquimia.hook.tsx
 import { useEffect as useEffect2, useState } from "react";
+
 // src/context/session-context.tsx
-import React2, { createContext, useContext, useEffect, useReducer } from "react";
+import { createContext, useContext, useEffect, useReducer } from "react";
+
 // src/reducer/characterization-reducer.tsx
-var characterizationReducer = function(state, action) {
-    switch(action.type){
-        case "SET_SESSION":
-            return _object_spread_props(_object_spread({}, state), {
-                sessionId: action.payload.sessionId,
-                characterizationData: action.payload.characterizationData
-            });
-        case "CLEAR_SESSION":
-            return _object_spread_props(_object_spread({}, state), {
-                sessionId: null,
-                characterizationData: null
-            });
-        default:
-            return state;
-    }
+var characterizationReducer = (state, action) => {
+  switch (action.type) {
+    case "SET_SESSION":
+      return {
+        ...state,
+        sessionId: action.payload.sessionId,
+        characterizationData: action.payload.characterizationData
+      };
+    case "CLEAR_SESSION":
+      return {
+        ...state,
+        sessionId: null,
+        characterizationData: null
+      };
+    default:
+      return state;
+  }
 };
+
 // src/context/session-context.tsx
 import { openDB } from "idb";
+import { jsx as jsx4 } from "react/jsx-runtime";
 var initialState = {
-    sessionId: null,
-    characterizationData: null
+  sessionId: null,
+  characterizationData: null
 };
 var AlquimiaContext = createContext(null);
-var useSessionContext = function() {
-    var context = useContext(AlquimiaContext);
-    if (!context) {
-        console.warn("useSessionContext must be used within a session provider. Returning default value.");
-        return {
-            userSessionState: initialState,
-            saveUserSession: null
-        };
-    }
-    return context;
-};
-var SessionProvider = function(param) {
-    var children = param.children;
-    var _useReducer = _sliced_to_array(useReducer(characterizationReducer, initialState), 2), userSessionState = _useReducer[0], sessionDispatch = _useReducer[1];
-    useEffect(function() {
-        getSession();
-    }, []);
-    var getSession = /*#__PURE__*/ function() {
-        var _ref = _async_to_generator(function() {
-            var userCookie, db, sessionIdEntry, characterizationDataEntry, sessionDataMatchesCookie;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            getCookies("alquimia-session")
-                        ];
-                    case 1:
-                        userCookie = _state.sent() || "";
-                        return [
-                            4,
-                            openDB("alquimiaDB", 1, {
-                                upgrade: function upgrade(db2) {
-                                    if (!db2.objectStoreNames.contains("session")) {
-                                        db2.createObjectStore("session", {
-                                            keyPath: "key"
-                                        });
-                                    }
-                                }
-                            })
-                        ];
-                    case 2:
-                        db = _state.sent();
-                        return [
-                            4,
-                            db.get("session", "sessionId")
-                        ];
-                    case 3:
-                        sessionIdEntry = _state.sent();
-                        return [
-                            4,
-                            db.get("session", "characterizationData")
-                        ];
-                    case 4:
-                        characterizationDataEntry = _state.sent();
-                        sessionDataMatchesCookie = (sessionIdEntry === null || sessionIdEntry === void 0 ? void 0 : sessionIdEntry.value) === userCookie;
-                        if (sessionIdEntry && characterizationDataEntry && sessionDataMatchesCookie) {
-                            sessionDispatch({
-                                type: "SET_SESSION",
-                                payload: {
-                                    sessionId: sessionIdEntry.value,
-                                    characterizationData: characterizationDataEntry.value
-                                }
-                            });
-                        }
-                        return [
-                            2
-                        ];
-                }
-            });
-        });
-        return function getSession() {
-            return _ref.apply(this, arguments);
-        };
-    }();
-    var saveUserSession = /*#__PURE__*/ function() {
-        var _ref = _async_to_generator(function(id, data) {
-            var db;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            openDB("alquimiaDB", 1)
-                        ];
-                    case 1:
-                        db = _state.sent();
-                        return [
-                            4,
-                            db.put("session", {
-                                key: "sessionId",
-                                value: id
-                            })
-                        ];
-                    case 2:
-                        _state.sent();
-                        return [
-                            4,
-                            db.put("session", {
-                                key: "characterizationData",
-                                value: data
-                            })
-                        ];
-                    case 3:
-                        _state.sent();
-                        sessionDispatch({
-                            type: "SET_SESSION",
-                            payload: {
-                                sessionId: id,
-                                characterizationData: data
-                            }
-                        });
-                        return [
-                            2
-                        ];
-                }
-            });
-        });
-        return function saveUserSession(id, data) {
-            return _ref.apply(this, arguments);
-        };
-    }();
-    var getSessionData = function() {
-        return userSessionState;
+var useSessionContext = () => {
+  const context = useContext(AlquimiaContext);
+  if (!context) {
+    console.warn("useSessionContext must be used within a session provider. Returning default value.");
+    return {
+      userSessionState: initialState,
+      saveUserSession: null
     };
-    return /* @__PURE__ */ React2.createElement(AlquimiaContext.Provider, {
-        value: {
-            userSessionState: userSessionState,
-            getSessionData: getSessionData,
-            saveUserSession: saveUserSession
+  }
+  return context;
+};
+var SessionProvider = ({ children }) => {
+  const [userSessionState, sessionDispatch] = useReducer(characterizationReducer, initialState);
+  useEffect(() => {
+    getSession();
+  }, []);
+  const getSession = async () => {
+    const userCookie = await getCookies("alquimia-session") || "";
+    const db = await openDB("alquimiaDB", 1, {
+      upgrade(db2) {
+        if (!db2.objectStoreNames.contains("session")) {
+          db2.createObjectStore("session", { keyPath: "key" });
         }
-    }, children);
+      }
+    });
+    const sessionIdEntry = await db.get("session", "sessionId");
+    const characterizationDataEntry = await db.get("session", "characterizationData");
+    const sessionDataMatchesCookie = sessionIdEntry?.value === userCookie;
+    if (sessionIdEntry && characterizationDataEntry && sessionDataMatchesCookie) {
+      sessionDispatch({
+        type: "SET_SESSION",
+        payload: {
+          sessionId: sessionIdEntry.value,
+          characterizationData: characterizationDataEntry.value
+        }
+      });
+    }
+  };
+  const saveUserSession = async (id, data) => {
+    const db = await openDB("alquimiaDB", 1);
+    await db.put("session", { key: "sessionId", value: id });
+    await db.put("session", { key: "characterizationData", value: data });
+    sessionDispatch({
+      type: "SET_SESSION",
+      payload: { sessionId: id, characterizationData: data }
+    });
+  };
+  const getSessionData = () => {
+    return userSessionState;
+  };
+  return /* @__PURE__ */ jsx4(AlquimiaContext.Provider, { value: { userSessionState, getSessionData, saveUserSession }, children });
 };
+
 // src/hooks/alquimia.hook.tsx
 function useAlquimia(sdk) {
-    var _useState = _sliced_to_array(useState(""), 2), chunkReceived = _useState[0], setChunkReceived = _useState[1];
-    var _useState1 = _sliced_to_array(useState(""), 2), currentMessageIdChuncked = _useState1[0], setCurrentMessageIdChuncked = _useState1[1];
-    var _useState2 = _sliced_to_array(useState(""), 2), input = _useState2[0], setInput = _useState2[1];
-    var _useState3 = _sliced_to_array(useState(false), 2), isLoading = _useState3[0], setIsLoading = _useState3[1];
-    var _useState4 = _sliced_to_array(useState(false), 2), isMessageStreaming = _useState4[0], setIsMessageStreaming = _useState4[1];
-    var _useState5 = _sliced_to_array(useState(null), 2), streamingMessageId = _useState5[0], setStreamingMessageId = _useState5[1];
-    var _useState6 = _sliced_to_array(useState(false), 2), isAudioRecording = _useState6[0], setIsAudioRecording = _useState6[1];
-    var _useState7 = _sliced_to_array(useState(null), 2), messageMetaData = _useState7[0], setMessageMetaData = _useState7[1];
-    var _useState8 = _sliced_to_array(useState([]), 2), messages = _useState8[0], setMessages = _useState8[1];
-    var _useState9 = _sliced_to_array(useState(null), 2), sessionId = _useState9[0], setSessionId = _useState9[1];
-    var _useState10 = _sliced_to_array(useState(null), 2), activeTool = _useState10[0], setActiveTool = _useState10[1];
-    var _useState11 = _sliced_to_array(useState(null), 2), lastRequest = _useState11[0], setLastRequest = _useState11[1];
-    var _useSessionContext = useSessionContext(), userSessionState = _useSessionContext.userSessionState, saveUserSession = _useSessionContext.saveUserSession;
-    var shouldShowCharacterizationButton = sdk.getEnforceCharacterization() && !(userSessionState === null || userSessionState === void 0 ? void 0 : userSessionState.characterizationData);
-    useEffect2(function() {
-        if (chunkReceived) processMessageChunk(currentMessageIdChuncked, chunkReceived);
-    }, [
-        chunkReceived
-    ]);
-    useEffect2(function() {
-        if ((userSessionState === null || userSessionState === void 0 ? void 0 : userSessionState.characterizationData) && sdk.getEnforceCharacterization()) {
-            sdk.withExtraData(userSessionState === null || userSessionState === void 0 ? void 0 : userSessionState.characterizationData);
-        }
-    }, [
-        userSessionState
-    ]);
-    function cleanMessages() {
-        setMessages([]);
-    }
-    function processMessageChunk(messageId, chunk, error_code, error_detail, additionalInfo) {
-        return _processMessageChunk.apply(this, arguments);
-    }
-    function _processMessageChunk() {
-        _processMessageChunk = _async_to_generator(function(messageId, chunk, error_code, error_detail, additionalInfo) {
-            return _ts_generator(this, function(_state) {
-                setMessages(function(currentMessages) {
-                    var messageIndex = currentMessages.findIndex(function(message) {
-                        return message.id === messageId;
-                    });
-                    if (messageIndex !== -1) {
-                        var _updatedMessages_messageIndex, _updatedMessages_messageIndex1, _updatedMessages_messageIndex2;
-                        var updatedMessages = _to_consumable_array(currentMessages);
-                        var updatedMessage = _object_spread_props(_object_spread({}, updatedMessages[messageIndex]), {
-                            content: "".concat(((_updatedMessages_messageIndex = updatedMessages[messageIndex]) === null || _updatedMessages_messageIndex === void 0 ? void 0 : _updatedMessages_messageIndex.content) || "").concat(chunk),
-                            id: ((_updatedMessages_messageIndex1 = updatedMessages[messageIndex]) === null || _updatedMessages_messageIndex1 === void 0 ? void 0 : _updatedMessages_messageIndex1.id) || "",
-                            role: ((_updatedMessages_messageIndex2 = updatedMessages[messageIndex]) === null || _updatedMessages_messageIndex2 === void 0 ? void 0 : _updatedMessages_messageIndex2.role) || "assistant",
-                            error_code: error_code,
-                            error_detail: error_detail,
-                            additionalInfo: additionalInfo,
-                            created_at: /* @__PURE__ */ new Date().getTime().toString()
-                        });
-                        updatedMessages[messageIndex] = updatedMessage;
-                        return updatedMessages;
-                    } else {
-                        return _to_consumable_array(currentMessages).concat([
-                            {
-                                content: "".concat(chunk),
-                                role: "assistant",
-                                id: messageId,
-                                error_code: error_code,
-                                error_detail: error_detail,
-                                created_at: /* @__PURE__ */ new Date().getTime().toString()
-                            }
-                        ]);
-                    }
-                });
-                return [
-                    2
-                ];
-            });
-        });
-        return _processMessageChunk.apply(this, arguments);
-    }
-    function handleSubmit(event, traceParentId, sessionId2, additionalInfo) {
-        return _handleSubmit.apply(this, arguments);
-    }
-    function _handleSubmit() {
-        _handleSubmit = _async_to_generator(function(event, traceParentId, sessionId2, additionalInfo) {
-            var messageId;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        setIsLoading(true);
-                        event.preventDefault();
-                        if (!input) return [
-                            3,
-                            2
-                        ];
-                        addUserMessage(input);
-                        messageId = createMessageId();
-                        setCurrentMessageIdChuncked(messageId);
-                        setStreamingMessageId(messageId);
-                        return [
-                            4,
-                            sendMessage(input, function(chunk) {
-                                var _chunk_data;
-                                processMessageChunk(messageId, (chunk === null || chunk === void 0 ? void 0 : (_chunk_data = chunk.data) === null || _chunk_data === void 0 ? void 0 : _chunk_data.content) || "", chunk === null || chunk === void 0 ? void 0 : chunk.error_code, chunk === null || chunk === void 0 ? void 0 : chunk.error_detail, additionalInfo);
-                            }, traceParentId, sessionId2)
-                        ];
-                    case 1:
-                        _state.sent();
-                        setInput("");
-                        _state.label = 2;
-                    case 2:
-                        setIsLoading(false);
-                        return [
-                            2
-                        ];
-                }
-            });
-        });
-        return _handleSubmit.apply(this, arguments);
-    }
-    function handleInputChange(event) {
-        setInput(event.target.value);
+  const [chunkReceived, setChunkReceived] = useState("");
+  const [currentMessageIdChuncked, setCurrentMessageIdChuncked] = useState("");
+  const [input, setInput] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const [isMessageStreaming, setIsMessageStreaming] = useState(false);
+  const [streamingMessageId, setStreamingMessageId] = useState(null);
+  const [isAudioRecording, setIsAudioRecording] = useState(false);
+  const [messageMetaData, setMessageMetaData] = useState(null);
+  const [messages, setMessages] = useState([]);
+  const [sessionId, setSessionId] = useState(null);
+  const [activeTool, setActiveTool] = useState(null);
+  const [lastRequest, setLastRequest] = useState(null);
+  const { userSessionState, saveUserSession } = useSessionContext();
+  const shouldShowCharacterizationButton = sdk.getEnforceCharacterization() && !userSessionState?.characterizationData;
+  useEffect2(() => {
+    if (chunkReceived)
+      processMessageChunk(currentMessageIdChuncked, chunkReceived);
+  }, [chunkReceived]);
+  useEffect2(() => {
+    if (userSessionState?.characterizationData && sdk.getEnforceCharacterization()) {
+      sdk.withExtraData(userSessionState?.characterizationData);
     }
-    function handleReplaceInput(input2) {
-        setInput(input2);
-    }
-    function populateMessages(messages2) {
-        setMessages(messages2);
-    }
-    function handleLoadingCancel() {
-        setIsLoading(false);
-        setIsMessageStreaming(false);
-        setInput("");
-    }
-    function addUserMessage(message) {
-        setMessages(function(prevMessages) {
-            return _to_consumable_array(prevMessages).concat([
-                {
-                    content: message,
-                    role: "user",
-                    id: createMessageId(),
-                    created_at: /* @__PURE__ */ new Date().getTime().toString()
-                }
-            ]);
-        });
-    }
-    function getCookie(name) {
-        var cookies2 = document.cookie.split(";");
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = cookies2[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var cookie = _step.value;
-                var _cookie_trim_split = _sliced_to_array(cookie.trim().split("="), 2), cookieName = _cookie_trim_split[0], cookieValue = _cookie_trim_split[1];
-                if (cookieName === name) {
-                    return decodeURIComponent(cookieValue);
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-        return null;
+  }, [userSessionState]);
+  function cleanMessages() {
+    setMessages([]);
+  }
+  async function processMessageChunk(messageId, chunk, error_code, error_detail, additionalInfo) {
+    setMessages((currentMessages) => {
+      const messageIndex = currentMessages.findIndex(
+        (message) => message.id === messageId
+      );
+      if (messageIndex !== -1) {
+        const updatedMessages = [...currentMessages];
+        const updatedMessage = {
+          ...updatedMessages[messageIndex],
+          content: `${updatedMessages[messageIndex]?.content || ""}${chunk}`,
+          id: updatedMessages[messageIndex]?.id || "",
+          role: updatedMessages[messageIndex]?.role || "assistant",
+          error_code,
+          error_detail,
+          additionalInfo,
+          created_at: (/* @__PURE__ */ new Date()).getTime().toString()
+        };
+        updatedMessages[messageIndex] = updatedMessage;
+        return updatedMessages;
+      } else {
+        return [
+          ...currentMessages,
+          {
+            content: `${chunk}`,
+            role: "assistant",
+            id: messageId,
+            error_code,
+            error_detail,
+            created_at: (/* @__PURE__ */ new Date()).getTime().toString()
+          }
+        ];
+      }
+    });
+  }
+  async function handleSubmit(event, traceParentId, sessionId2, additionalInfo) {
+    setIsLoading(true);
+    event.preventDefault();
+    if (input) {
+      addUserMessage(input);
+      const messageId = createMessageId();
+      setCurrentMessageIdChuncked(messageId);
+      setStreamingMessageId(messageId);
+      await sendMessage(input, (chunk) => {
+        processMessageChunk(
+          messageId,
+          chunk?.data?.content || "",
+          chunk?.error_code,
+          chunk?.error_detail,
+          additionalInfo
+        );
+      }, traceParentId, sessionId2);
+      setInput("");
     }
-    function sendMessage(message, callBack, traceParentId, sessionId2) {
-        return _sendMessage.apply(this, arguments);
+    setIsLoading(false);
+  }
+  function handleInputChange(event) {
+    setInput(event.target.value);
+  }
+  function handleReplaceInput(input2) {
+    setInput(input2);
+  }
+  function populateMessages(messages2) {
+    setMessages(messages2);
+  }
+  function handleLoadingCancel() {
+    setIsLoading(false);
+    setIsMessageStreaming(false);
+    setInput("");
+  }
+  function addUserMessage(message) {
+    setMessages((prevMessages) => [
+      ...prevMessages,
+      {
+        content: message,
+        role: "user",
+        id: createMessageId(),
+        created_at: (/* @__PURE__ */ new Date()).getTime().toString()
+      }
+    ]);
+  }
+  function getCookie(name) {
+    const cookies2 = document.cookie.split(";");
+    for (let cookie of cookies2) {
+      const [cookieName, cookieValue] = cookie.trim().split("=");
+      if (cookieName === name) {
+        return decodeURIComponent(cookieValue);
+      }
     }
-    function _sendMessage() {
-        _sendMessage = _async_to_generator(function(message, callBack, traceParentId, sessionId2) {
-            var conversationId, response, es;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        conversationId = sessionId2 || getCookie("alquimia-session");
-                        setIsMessageStreaming(true);
-                        setActiveTool(null);
-                        setLastRequest(message);
-                        return [
-                            4,
-                            sdk.widthConversationId(conversationId || "").sendMessage(message, traceParentId)
-                        ];
-                    case 1:
-                        response = _state.sent();
-                        es = new EventSource(response.getUrlStream());
-                        es.onmessage = function(event) {
-                            var parsedData = JSON.parse(event.data);
-                            if (parsedData.tooler && parsedData.tooler.length > 0 && !activeTool) {
-                                setActiveTool({
-                                    tooler: parsedData.tooler
-                                });
-                            }
-                            if (parsedData.error_code) {
-                                callBack({
-                                    type: "error",
-                                    error_code: parsedData.error_code,
-                                    error_detail: parsedData.error_detail
-                                });
-                            }
-                            if (parsedData.is_complete) {
-                                setIsMessageStreaming(false);
-                                setStreamingMessageId(null);
-                                es.close();
-                            } else {
-                                callBack(parsedData.answer);
-                            }
-                        };
-                        return [
-                            2
-                        ];
-                }
-            });
+    return null;
+  }
+  async function sendMessage(message, callBack, traceParentId, sessionId2) {
+    const conversationId = sessionId2 || getCookie("alquimia-session");
+    setIsMessageStreaming(true);
+    setActiveTool(null);
+    setLastRequest(message);
+    const response = await sdk.widthConversationId(conversationId || "").sendMessage(message, traceParentId);
+    const es = new EventSource(response.getUrlStream());
+    es.onmessage = (event) => {
+      const parsedData = JSON.parse(event.data);
+      if (parsedData.tooler && parsedData.tooler.length > 0 && !activeTool) {
+        setActiveTool({
+          tooler: parsedData.tooler
         });
-        return _sendMessage.apply(this, arguments);
-    }
-    function handleSaveCharacterization(translation) {
-        return _handleSaveCharacterization.apply(this, arguments);
-    }
-    function _handleSaveCharacterization() {
-        _handleSaveCharacterization = _async_to_generator(function(translation) {
-            var conversationId;
-            return _ts_generator(this, function(_state) {
-                conversationId = getCookie("alquimia-session");
-                if (!conversationId || !saveUserSession) return [
-                    2
-                ];
-                saveUserSession(conversationId, translation);
-                return [
-                    2
-                ];
-            });
+      }
+      if (parsedData.error_code) {
+        callBack({
+          type: "error",
+          error_code: parsedData.error_code,
+          error_detail: parsedData.error_detail
         });
-        return _handleSaveCharacterization.apply(this, arguments);
-    }
-    return {
-        activeTool: activeTool,
-        cleanMessages: cleanMessages,
-        createMessageId: createMessageId,
-        handleInputChange: handleInputChange,
-        handleReplaceInput: handleReplaceInput,
-        handleSubmit: handleSubmit,
-        handleSaveCharacterization: handleSaveCharacterization,
-        handleLoadingCancel: handleLoadingCancel,
-        input: input,
-        isLoading: isLoading,
-        isMessageStreaming: isMessageStreaming,
-        streamingMessageId: streamingMessageId,
-        isAudioRecording: isAudioRecording,
-        shouldShowCharacterizationButton: shouldShowCharacterizationButton,
-        lastRequest: lastRequest,
-        messageMetaData: messageMetaData,
-        messages: messages,
-        populateMessages: populateMessages,
-        processMessageChunk: processMessageChunk,
-        sendMessage: sendMessage,
-        sessionId: sessionId,
-        setActiveTool: setActiveTool,
-        setSessionId: setSessionId,
-        setLastRequest: setLastRequest,
-        setIsAudioRecording: setIsAudioRecording
+      }
+      if (parsedData.is_complete) {
+        setIsMessageStreaming(false);
+        setStreamingMessageId(null);
+        es.close();
+      } else {
+        callBack(parsedData.answer);
+      }
     };
+  }
+  async function handleSaveCharacterization(translation) {
+    const conversationId = getCookie("alquimia-session");
+    if (!conversationId || !saveUserSession) return;
+    saveUserSession(conversationId, translation);
+  }
+  return {
+    activeTool,
+    cleanMessages,
+    createMessageId,
+    handleInputChange,
+    handleReplaceInput,
+    handleSubmit,
+    handleSaveCharacterization,
+    handleLoadingCancel,
+    input,
+    isLoading,
+    isMessageStreaming,
+    streamingMessageId,
+    isAudioRecording,
+    shouldShowCharacterizationButton,
+    lastRequest,
+    messageMetaData,
+    messages,
+    populateMessages,
+    processMessageChunk,
+    sendMessage,
+    sessionId,
+    setActiveTool,
+    setSessionId,
+    setLastRequest,
+    setIsAudioRecording
+  };
 }
+
 // src/hooks/useRatings.ts
 import { useState as useState2, useReducer as useReducer2 } from "react";
 var initialState2 = {
-    ratingStars: 0,
-    ratingThumbs: "",
-    ratingComment: ""
+  ratingStars: 0,
+  ratingThumbs: "",
+  ratingComment: ""
 };
 function ratingReducer(state, action) {
-    switch(action.type){
-        case "SET_RATING_STARS":
-            return _object_spread_props(_object_spread({}, state), {
-                ratingStars: action.payload
-            });
-        case "SET_RATING_THUMBS":
-            return _object_spread_props(_object_spread({}, state), {
-                ratingThumbs: action.payload
-            });
-        case "SET_RATING_COMMENT":
-            return _object_spread_props(_object_spread({}, state), {
-                ratingComment: action.payload
-            });
-        default:
-            return state;
-    }
+  switch (action.type) {
+    case "SET_RATING_STARS":
+      return { ...state, ratingStars: action.payload };
+    case "SET_RATING_THUMBS":
+      return { ...state, ratingThumbs: action.payload };
+    case "SET_RATING_COMMENT":
+      return { ...state, ratingComment: action.payload };
+    default:
+      return state;
+  }
 }
-function useRatings(param) {
-    var assistantId = param.assistantId, sendRating = param.sendRating, topicId = param.topicId;
-    var _useState2 = _sliced_to_array(useState2(false), 2), isLoading = _useState2[0], setIsLoading = _useState2[1];
-    var _useState21 = _sliced_to_array(useState2(false), 2), hasReviewed = _useState21[0], setHasReviewed = _useState21[1];
-    var _useReducer2 = _sliced_to_array(useReducer2(ratingReducer, initialState2), 2), state = _useReducer2[0], dispatch = _useReducer2[1];
-    var setRatingStars = function(rating) {
-        dispatch({
-            type: "SET_RATING_STARS",
-            payload: rating
-        });
-    };
-    var setRatingThumbs = function(rating) {
-        dispatch({
-            type: "SET_RATING_THUMBS",
-            payload: rating
-        });
-    };
-    var setRatingComment = function(comment) {
-        dispatch({
-            type: "SET_RATING_COMMENT",
-            payload: comment
-        });
-    };
-    var thumbsScore = function(value) {
-        return value === "thumbsUp" ? 5 : value === "thumbsDown" ? 0 : 0;
-    };
-    var handleRate = /*#__PURE__*/ function() {
-        var _ref = _async_to_generator(function(key, value, onHandleRateSuccess) {
-            var sessionId, ratingObj, response, err;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        setIsLoading(true);
-                        sessionId = getTopicSessionId(topicId);
-                        ratingObj = {
-                            topicId: parseInt(topicId),
-                            sessionId: sessionId || "",
-                            assistantId: assistantId,
-                            score: key === "score" ? value : thumbsScore(value),
-                            description: key === "description" ? value : state.ratingComment
-                        };
-                        _state.label = 1;
-                    case 1:
-                        _state.trys.push([
-                            1,
-                            3,
-                            ,
-                            4
-                        ]);
-                        return [
-                            4,
-                            sendRating(ratingObj)
-                        ];
-                    case 2:
-                        response = _state.sent();
-                        if (!response.success) {
-                            setIsLoading(false);
-                            onHandleRateSuccess(false, response.error.message);
-                            return [
-                                2
-                            ];
-                        }
-                        if (key === "score") {
-                            setRatingStars(value);
-                        } else if (key === "description") {
-                            setRatingComment(value);
-                        }
-                        setHasReviewed(true);
-                        setIsLoading(false);
-                        onHandleRateSuccess(true);
-                        return [
-                            3,
-                            4
-                        ];
-                    case 3:
-                        err = _state.sent();
-                        setIsLoading(false);
-                        onHandleRateSuccess(false, String(err));
-                        return [
-                            3,
-                            4
-                        ];
-                    case 4:
-                        return [
-                            2
-                        ];
-                }
-            });
-        });
-        return function handleRate(key, value, onHandleRateSuccess) {
-            return _ref.apply(this, arguments);
-        };
-    }();
-    return {
-        handleRate: handleRate,
-        ratingStars: state.ratingStars,
-        ratingThumbs: state.ratingThumbs,
-        ratingComment: state.ratingComment,
-        isLoading: isLoading,
-        hasReviewed: hasReviewed
+function useRatings({ assistantId, sendRating, topicId }) {
+  const [isLoading, setIsLoading] = useState2(false);
+  const [hasReviewed, setHasReviewed] = useState2(false);
+  const [state, dispatch] = useReducer2(ratingReducer, initialState2);
+  const setRatingStars = (rating) => {
+    dispatch({ type: "SET_RATING_STARS", payload: rating });
+  };
+  const setRatingThumbs = (rating) => {
+    dispatch({ type: "SET_RATING_THUMBS", payload: rating });
+  };
+  const setRatingComment = (comment) => {
+    dispatch({ type: "SET_RATING_COMMENT", payload: comment });
+  };
+  const thumbsScore = (value) => {
+    return value === "thumbsUp" ? 5 : value === "thumbsDown" ? 0 : 0;
+  };
+  const handleRate = async (key, value, onHandleRateSuccess) => {
+    setIsLoading(true);
+    const sessionId = getTopicSessionId(topicId);
+    const ratingObj = {
+      topicId: parseInt(topicId),
+      sessionId: sessionId || "",
+      assistantId,
+      score: key === "score" ? value : thumbsScore(value),
+      description: key === "description" ? value : state.ratingComment
     };
+    try {
+      const response = await sendRating(ratingObj);
+      if (!response.success) {
+        setIsLoading(false);
+        onHandleRateSuccess(false, response.error.message);
+        return;
+      }
+      if (key === "score") {
+        setRatingStars(value);
+      } else if (key === "description") {
+        setRatingComment(value);
+      }
+      setHasReviewed(true);
+      setIsLoading(false);
+      onHandleRateSuccess(true);
+    } catch (err) {
+      setIsLoading(false);
+      onHandleRateSuccess(false, String(err));
+    }
+  };
+  return {
+    handleRate,
+    ratingStars: state.ratingStars,
+    ratingThumbs: state.ratingThumbs,
+    ratingComment: state.ratingComment,
+    isLoading,
+    hasReviewed
+  };
 }
+
 // src/actions/alquimia.action.ts
 import { randomUUID } from "crypto";
 import { cookies } from "next/headers";
-function initConversation(reset, topicId) {
-    return _initConversation.apply(this, arguments);
-}
-function _initConversation() {
-    _initConversation = _async_to_generator(function(reset, topicId) {
-        var cookieStore, conversationId, alquimia_session, conversationsMap, existingConversations, decodedValue;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    return [
-                        4,
-                        cookies()
-                    ];
-                case 1:
-                    cookieStore = _state.sent();
-                    if (!topicId) {
-                        conversationId = randomUUID().toString();
-                        alquimia_session = cookieStore.get("alquimia-session");
-                        if (!alquimia_session || reset) {
-                            cookieStore.set("alquimia-session", conversationId);
-                        } else {
-                            conversationId = alquimia_session.value;
-                        }
-                        return [
-                            2,
-                            conversationId
-                        ];
-                    }
-                    conversationsMap = {};
-                    existingConversations = cookieStore.get("alquimia-sessions");
-                    if (existingConversations) {
-                        try {
-                            decodedValue = decodeURIComponent(existingConversations.value);
-                            conversationsMap = JSON.parse(decodedValue);
-                        } catch (e) {
-                            console.error("Error parsing conversations cookie:", e);
-                            conversationsMap = {};
-                        }
-                    }
-                    if (!conversationsMap[topicId] || reset) {
-                        conversationsMap[topicId] = randomUUID().toString();
-                    }
-                    cookieStore.set("alquimia-sessions", JSON.stringify(conversationsMap));
-                    return [
-                        2,
-                        conversationsMap[topicId]
-                    ];
-            }
-        });
-    });
-    return _initConversation.apply(this, arguments);
-}
-function createResource(config, payload) {
-    return _createResource.apply(this, arguments);
+async function initConversation(reset, topicId) {
+  const cookieStore = await cookies();
+  if (!topicId) {
+    let conversationId = randomUUID().toString();
+    const alquimia_session = cookieStore.get("alquimia-session");
+    if (!alquimia_session || reset) {
+      cookieStore.set("alquimia-session", conversationId);
+    } else {
+      conversationId = alquimia_session.value;
+    }
+    return conversationId;
+  }
+  let conversationsMap = {};
+  const existingConversations = cookieStore.get("alquimia-sessions");
+  if (existingConversations) {
+    try {
+      const decodedValue = decodeURIComponent(existingConversations.value);
+      conversationsMap = JSON.parse(decodedValue);
+    } catch (e) {
+      console.error("Error parsing conversations cookie:", e);
+      conversationsMap = {};
+    }
+  }
+  if (!conversationsMap[topicId] || reset) {
+    conversationsMap[topicId] = randomUUID().toString();
+  }
+  cookieStore.set("alquimia-sessions", JSON.stringify(conversationsMap));
+  return conversationsMap[topicId];
 }
-function _createResource() {
-    _createResource = // src/actions/baseApi.action.ts
-    _async_to_generator(function(config, payload) {
-        var headers, response, error, _tmp, error1;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    _state.trys.push([
-                        0,
-                        5,
-                        ,
-                        6
-                    ]);
-                    headers = generateHeaders(config);
-                    return [
-                        4,
-                        fetch("".concat(config.baseUrl).concat(config.route), {
-                            method: "POST",
-                            headers: headers,
-                            body: JSON.stringify(payload),
-                            cache: "default"
-                        })
-                    ];
-                case 1:
-                    response = _state.sent();
-                    if (!!response.ok) return [
-                        3,
-                        3
-                    ];
-                    return [
-                        4,
-                        response.json()
-                    ];
-                case 2:
-                    error = _state.sent();
-                    return [
-                        2,
-                        {
-                            success: false,
-                            error: {
-                                message: error.message || "Server returned ".concat(response.status),
-                                code: response.status.toString(),
-                                details: {
-                                    status: response.status,
-                                    statusText: response.statusText
-                                }
-                            }
-                        }
-                    ];
-                case 3:
-                    _tmp = {
-                        success: true
-                    };
-                    return [
-                        4,
-                        response.json()
-                    ];
-                case 4:
-                    return [
-                        2,
-                        (_tmp.data = _state.sent(), _tmp)
-                    ];
-                case 5:
-                    error1 = _state.sent();
-                    throw new Error("Failed to create resource");
-                case 6:
-                    return [
-                        2
-                    ];
-            }
-        });
+
+// src/actions/baseApi.action.ts
+async function createResource(config, payload) {
+  try {
+    const headers = generateHeaders(config);
+    const response = await fetch(`${config.baseUrl}${config.route}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      cache: "default"
     });
-    return _createResource.apply(this, arguments);
-}
-function readResource(config, id) {
-    return _readResource.apply(this, arguments);
+    if (!response.ok) {
+      const error = await response.json();
+      return {
+        success: false,
+        error: {
+          message: error.message || `Server returned ${response.status}`,
+          code: response.status.toString(),
+          details: {
+            status: response.status,
+            statusText: response.statusText
+          }
+        }
+      };
+    }
+    return {
+      success: true,
+      data: await response.json()
+    };
+  } catch (error) {
+    throw new Error("Failed to create resource");
+  }
 }
-function _readResource() {
-    _readResource = _async_to_generator(function(config, id) {
-        var headers, url, response, error, contentType, _tmp, arrayBuffer, _tmp1, error1;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    _state.trys.push([
-                        0,
-                        8,
-                        ,
-                        9
-                    ]);
-                    headers = generateHeaders(config);
-                    url = id ? "".concat(config.baseUrl).concat(config.route, "/").concat(id) : "".concat(config.baseUrl).concat(config.route);
-                    return [
-                        4,
-                        fetch(url, {
-                            method: "GET",
-                            headers: headers,
-                            cache: "default"
-                        })
-                    ];
-                case 1:
-                    response = _state.sent();
-                    if (!!response.ok) return [
-                        3,
-                        3
-                    ];
-                    return [
-                        4,
-                        response.json()
-                    ];
-                case 2:
-                    error = _state.sent();
-                    return [
-                        2,
-                        {
-                            success: false,
-                            error: {
-                                message: error.message || "Server returned ".concat(response.status),
-                                code: response.status.toString(),
-                                details: {
-                                    status: response.status,
-                                    statusText: response.statusText
-                                }
-                            }
-                        }
-                    ];
-                case 3:
-                    contentType = response.headers.get("content-type");
-                    if (!(contentType === null || contentType === void 0 ? void 0 : contentType.includes("application/json"))) return [
-                        3,
-                        5
-                    ];
-                    _tmp = {
-                        success: true
-                    };
-                    return [
-                        4,
-                        response.json()
-                    ];
-                case 4:
-                    return [
-                        2,
-                        (_tmp.data = _state.sent(), _tmp.contentType = contentType || void 0, _tmp)
-                    ];
-                case 5:
-                    return [
-                        4,
-                        response.arrayBuffer()
-                    ];
-                case 6:
-                    arrayBuffer = _state.sent();
-                    if ((contentType === null || contentType === void 0 ? void 0 : contentType.includes("octet-stream")) && isTextContent(arrayBuffer)) {
-                        return [
-                            2,
-                            {
-                                success: true,
-                                data: arrayBuffer,
-                                contentType: "text/plain"
-                            }
-                        ];
-                    }
-                    _tmp1 = {
-                        success: true
-                    };
-                    return [
-                        4,
-                        response.json()
-                    ];
-                case 7:
-                    return [
-                        2,
-                        (_tmp1.data = _state.sent(), _tmp1.contentType = contentType || void 0, _tmp1)
-                    ];
-                case 8:
-                    error1 = _state.sent();
-                    throw new Error("Failed to read resource");
-                case 9:
-                    return [
-                        2
-                    ];
-            }
-        });
+async function readResource(config, id) {
+  try {
+    const headers = generateHeaders(config);
+    const url = id ? `${config.baseUrl}${config.route}/${id}` : `${config.baseUrl}${config.route}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      cache: "default"
     });
-    return _readResource.apply(this, arguments);
-}
-function updateResource(config, id, data) {
-    return _updateResource.apply(this, arguments);
+    if (!response.ok) {
+      const error = await response.json();
+      return {
+        success: false,
+        error: {
+          message: error.message || `Server returned ${response.status}`,
+          code: response.status.toString(),
+          details: {
+            status: response.status,
+            statusText: response.statusText
+          }
+        }
+      };
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return {
+        success: true,
+        data: await response.json(),
+        contentType: contentType || void 0
+      };
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    if (contentType?.includes("octet-stream") && isTextContent(arrayBuffer)) {
+      return {
+        success: true,
+        data: arrayBuffer,
+        contentType: "text/plain"
+      };
+    }
+    return {
+      success: true,
+      data: await response.json(),
+      contentType: contentType || void 0
+    };
+  } catch (error) {
+    throw new Error("Failed to read resource");
+  }
 }
-function _updateResource() {
-    _updateResource = _async_to_generator(function(config, id, data) {
-        var headers, response, error, _tmp, error1;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    _state.trys.push([
-                        0,
-                        5,
-                        ,
-                        6
-                    ]);
-                    headers = generateHeaders(config);
-                    return [
-                        4,
-                        fetch("".concat(config.baseUrl).concat(config.route, "/").concat(id), {
-                            method: "PUT",
-                            headers: headers,
-                            body: JSON.stringify(data),
-                            cache: "default"
-                        })
-                    ];
-                case 1:
-                    response = _state.sent();
-                    if (!!response.ok) return [
-                        3,
-                        3
-                    ];
-                    return [
-                        4,
-                        response.json()
-                    ];
-                case 2:
-                    error = _state.sent();
-                    return [
-                        2,
-                        {
-                            success: false,
-                            error: {
-                                message: error.message || "Server returned ".concat(response.status),
-                                code: response.status.toString(),
-                                details: {
-                                    status: response.status,
-                                    statusText: response.statusText
-                                }
-                            }
-                        }
-                    ];
-                case 3:
-                    _tmp = {
-                        success: true
-                    };
-                    return [
-                        4,
-                        response.json()
-                    ];
-                case 4:
-                    return [
-                        2,
-                        (_tmp.data = _state.sent(), _tmp)
-                    ];
-                case 5:
-                    error1 = _state.sent();
-                    throw new Error("Failed to update resource");
-                case 6:
-                    return [
-                        2
-                    ];
-            }
-        });
+async function updateResource(config, id, data) {
+  try {
+    const headers = generateHeaders(config);
+    const response = await fetch(`${config.baseUrl}${config.route}/${id}`, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(data),
+      cache: "default"
     });
-    return _updateResource.apply(this, arguments);
-}
-function deleteResource(config, id) {
-    return _deleteResource.apply(this, arguments);
+    if (!response.ok) {
+      const error = await response.json();
+      return {
+        success: false,
+        error: {
+          message: error.message || `Server returned ${response.status}`,
+          code: response.status.toString(),
+          details: {
+            status: response.status,
+            statusText: response.statusText
+          }
+        }
+      };
+    }
+    return {
+      success: true,
+      data: await response.json()
+    };
+  } catch (error) {
+    throw new Error("Failed to update resource");
+  }
 }
-function _deleteResource() {
-    _deleteResource = _async_to_generator(function(config, id) {
-        var headers, response, error, error1;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    _state.trys.push([
-                        0,
-                        4,
-                        ,
-                        5
-                    ]);
-                    headers = generateHeaders(config);
-                    return [
-                        4,
-                        fetch("".concat(config.baseUrl).concat(config.route, "/").concat(id), {
-                            method: "DELETE",
-                            headers: headers,
-                            cache: "default"
-                        })
-                    ];
-                case 1:
-                    response = _state.sent();
-                    if (!!response.ok) return [
-                        3,
-                        3
-                    ];
-                    return [
-                        4,
-                        response.json()
-                    ];
-                case 2:
-                    error = _state.sent();
-                    return [
-                        2,
-                        {
-                            success: false,
-                            error: {
-                                message: error.message || "Server returned ".concat(response.status),
-                                code: response.status.toString(),
-                                details: {
-                                    status: response.status,
-                                    statusText: response.statusText
-                                }
-                            }
-                        }
-                    ];
-                case 3:
-                    return [
-                        2,
-                        {
-                            success: true
-                        }
-                    ];
-                case 4:
-                    error1 = _state.sent();
-                    throw new Error("Failed to delete resource");
-                case 5:
-                    return [
-                        2
-                    ];
-            }
-        });
+async function deleteResource(config, id) {
+  try {
+    const headers = generateHeaders(config);
+    const response = await fetch(`${config.baseUrl}${config.route}/${id}`, {
+      method: "DELETE",
+      headers,
+      cache: "default"
     });
-    return _deleteResource.apply(this, arguments);
+    if (!response.ok) {
+      const error = await response.json();
+      return {
+        success: false,
+        error: {
+          message: error.message || `Server returned ${response.status}`,
+          code: response.status.toString(),
+          details: {
+            status: response.status,
+            statusText: response.statusText
+          }
+        }
+      };
+    }
+    return {
+      success: true
+    };
+  } catch (error) {
+    throw new Error("Failed to delete resource");
+  }
 }
-export { AlquimiaRatingsProvider, alquimia_sdk_default as AlquimiaSDK, AlquimiaWhisperProvider, Button, Card, CharacterizationProvider, Code, ElasticLoggerProvider, ElevenLabsWhisperProvider, GenerativeProvider, LoggerProvider, OpenAIAnalyzeCharProvider, OpenAIStableDiffusionProvider, OpenAIWhisperProvider, RatingsProvider, SessionProvider, StabilityProvider, StableDiffusionProvider, WhisperProvider, createMessageId, createResource, defineAssistantId, deleteResource, formatTimeWithUnit, generateHeaders, generateTranslatePrompt, getCookies, getQueryParam, getTopicSessionId, initConversation, isTextContent, parseConversationsMapCookie, readResource, serializeAxiosError, updateResource, useAlquimia, useRatings, useSessionContext };
+
+// src/types/type.ts
+var ToolFactory = class {
+  constructor(toolSpec) {
+    this.toolSpec = null;
+    this.toolSpec = toolSpec;
+  }
+  static createTool(toolSpec) {
+    return toolSpec;
+  }
+};
+export {
+  AlquimiaRatingsProvider,
+  alquimia_sdk_default as AlquimiaSDK,
+  AlquimiaWhisperProvider,
+  Button,
+  Card,
+  CharacterizationProvider,
+  Code,
+  ElasticLoggerProvider,
+  ElevenLabsWhisperProvider,
+  GenerativeProvider,
+  LoggerProvider,
+  OpenAIAnalyzeCharProvider,
+  OpenAIStableDiffusionProvider,
+  OpenAIWhisperProvider,
+  RatingsProvider,
+  SessionProvider,
+  StabilityProvider,
+  StableDiffusionProvider,
+  ToolFactory,
+  WhisperProvider,
+  createMessageId,
+  createResource,
+  defineAssistantId,
+  deleteResource,
+  formatTimeWithUnit,
+  generateHeaders,
+  generateTranslatePrompt,
+  getCookies,
+  getQueryParam,
+  getTopicSessionId,
+  initConversation,
+  isTextContent,
+  parseConversationsMapCookie,
+  readResource,
+  serializeAxiosError,
+  updateResource,
+  useAlquimia,
+  useRatings,
+  useSessionContext
+};
 //# sourceMappingURL=index.mjs.map