@alquimia-ai/tools 1.0.1

package/dist/index.mjs

@@ -0,0 +1,2336 @@
+// 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");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    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;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(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 _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]);
+        });
+    }
+    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 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 target;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _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
+            ]);
+        };
+    }
+    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);
+};
+// 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);
+    this.config = config;
+};
+var WhisperProvider = function WhisperProvider(config) {
+    "use strict";
+    _class_call_check(this, WhisperProvider);
+    this.config = config;
+};
+var StableDiffusionProvider = function StableDiffusionProvider(config) {
+    "use strict";
+    _class_call_check(this, StableDiffusionProvider);
+    this.config = config;
+};
+var CharacterizationProvider = function CharacterizationProvider(config) {
+    "use strict";
+    _class_call_check(this, CharacterizationProvider);
+    this.config = config;
+};
+var RatingsProvider = function RatingsProvider(config) {
+    "use strict";
+    _class_call_check(this, RatingsProvider);
+    this.config = config;
+};
+var LoggerProvider = function LoggerProvider(config) {
+    "use strict";
+    _class_call_check(this, LoggerProvider);
+    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, [
+        {
+            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
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            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
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    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, [
+        {
+            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
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    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;
+}
+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();
+}
+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;
+}
+function isTextContent(buffer) {
+    try {
+        var text = new TextDecoder().decode(buffer);
+        return /^[\w\#\-\*]/.test(text.trim());
+    } catch (e) {
+        return false;
+    }
+}
+function getQueryParam(param) {
+    if (typeof window !== "undefined") {
+        var 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;
+    }
+    return defaultId;
+}
+function formatTimeWithUnit(timeMs) {
+    if (timeMs >= 1e3) {
+        return "".concat((timeMs / 1e3).toFixed(1), "s");
+    }
+    return "".concat(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
+        };
+    }
+    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 {};
+    }
+}
+function getTopicSessionId(topicId) {
+    var conversationsStr = getCookies("alquimia-sessions") || "{}";
+    if (!conversationsStr) {
+        var sessionCookie = getCookies("alquimia-session");
+        return sessionCookie || "";
+    }
+    var conversationsMap = parseConversationsMapCookie(conversationsStr);
+    return conversationsMap[topicId] || "";
+}
+function createMessageId() {
+    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;
+    }
+    _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);
+// 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
+                                ];
+                        }
+                    });
+                })();
+            }
+        }
+    ]);
+    return StabilityProvider;
+}(StableDiffusionProvider);
+// 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
+    }
+};
+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, [
+        {
+            key: "speechToText",
+            value: function speechToText(audio) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            ""
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            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);
+// 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
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "logInfo",
+            value: function logInfo(message, data) {
+                this.logger.info(_object_spread({}, data), message);
+            }
+        },
+        {
+            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);
+// 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";
+// 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;
+    }
+};
+// src/context/session-context.tsx
+import { openDB } from "idb";
+var initialState = {
+    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;
+    };
+    return /* @__PURE__ */ React2.createElement(AlquimiaContext.Provider, {
+        value: {
+            userSessionState: userSessionState,
+            getSessionData: getSessionData,
+            saveUserSession: 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);
+    }
+    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;
+    }
+    function sendMessage(message, callBack, traceParentId, sessionId2) {
+        return _sendMessage.apply(this, arguments);
+    }
+    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 _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
+                ];
+            });
+        });
+        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
+    };
+}
+// src/hooks/useRatings.ts
+import { useState as useState2, useReducer as useReducer2 } from "react";
+var initialState2 = {
+    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;
+    }
+}
+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
+    };
+}
+// 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);
+}
+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
+                    ];
+            }
+        });
+    });
+    return _createResource.apply(this, arguments);
+}
+function readResource(config, id) {
+    return _readResource.apply(this, arguments);
+}
+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
+                    ];
+            }
+        });
+    });
+    return _readResource.apply(this, arguments);
+}
+function updateResource(config, id, data) {
+    return _updateResource.apply(this, arguments);
+}
+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
+                    ];
+            }
+        });
+    });
+    return _updateResource.apply(this, arguments);
+}
+function deleteResource(config, id) {
+    return _deleteResource.apply(this, arguments);
+}
+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
+                    ];
+            }
+        });
+    });
+    return _deleteResource.apply(this, arguments);
+}
+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 };
+//# sourceMappingURL=index.mjs.map