@alquimia-ai/tools 1.0.1

package/dist/index.js

@@ -0,0 +1,2582 @@
+"use strict";
+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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toESM = function(mod, isNodeMode, target) {
+    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+        value: mod,
+        enumerable: true
+    }) : target, mod);
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+    AlquimiaRatingsProvider: function() {
+        return AlquimiaRatingsProvider;
+    },
+    AlquimiaSDK: function() {
+        return alquimia_sdk_default;
+    },
+    AlquimiaWhisperProvider: function() {
+        return AlquimiaWhisperProvider;
+    },
+    Button: function() {
+        return Button;
+    },
+    Card: function() {
+        return Card;
+    },
+    CharacterizationProvider: function() {
+        return CharacterizationProvider;
+    },
+    Code: function() {
+        return Code;
+    },
+    ElasticLoggerProvider: function() {
+        return ElasticLoggerProvider;
+    },
+    ElevenLabsWhisperProvider: function() {
+        return ElevenLabsWhisperProvider;
+    },
+    GenerativeProvider: function() {
+        return GenerativeProvider;
+    },
+    LoggerProvider: function() {
+        return LoggerProvider;
+    },
+    OpenAIAnalyzeCharProvider: function() {
+        return OpenAIAnalyzeCharProvider;
+    },
+    OpenAIStableDiffusionProvider: function() {
+        return OpenAIStableDiffusionProvider;
+    },
+    OpenAIWhisperProvider: function() {
+        return OpenAIWhisperProvider;
+    },
+    RatingsProvider: function() {
+        return RatingsProvider;
+    },
+    SessionProvider: function() {
+        return SessionProvider;
+    },
+    StabilityProvider: function() {
+        return StabilityProvider;
+    },
+    StableDiffusionProvider: function() {
+        return StableDiffusionProvider;
+    },
+    WhisperProvider: function() {
+        return WhisperProvider;
+    },
+    createMessageId: function() {
+        return createMessageId;
+    },
+    createResource: function() {
+        return createResource;
+    },
+    defineAssistantId: function() {
+        return defineAssistantId;
+    },
+    deleteResource: function() {
+        return deleteResource;
+    },
+    formatTimeWithUnit: function() {
+        return formatTimeWithUnit;
+    },
+    generateHeaders: function() {
+        return generateHeaders;
+    },
+    generateTranslatePrompt: function() {
+        return generateTranslatePrompt;
+    },
+    getCookies: function() {
+        return getCookies;
+    },
+    getQueryParam: function() {
+        return getQueryParam;
+    },
+    getTopicSessionId: function() {
+        return getTopicSessionId;
+    },
+    initConversation: function() {
+        return initConversation;
+    },
+    isTextContent: function() {
+        return isTextContent;
+    },
+    parseConversationsMapCookie: function() {
+        return parseConversationsMapCookie;
+    },
+    readResource: function() {
+        return readResource;
+    },
+    serializeAxiosError: function() {
+        return serializeAxiosError;
+    },
+    updateResource: function() {
+        return updateResource;
+    },
+    useAlquimia: function() {
+        return useAlquimia;
+    },
+    useRatings: function() {
+        return useRatings;
+    },
+    useSessionContext: function() {
+        return useSessionContext;
+    }
+});
+module.exports = __toCommonJS(index_exports);
+// src/button.tsx
+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
+var import_axios = __toESM(require("axios"));
+var AlquimiaSDK = /*#__PURE__*/ function() {
+    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 = import_axios.default.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) {
+    _class_call_check(this, GenerativeProvider);
+    this.config = config;
+};
+var WhisperProvider = function WhisperProvider(config) {
+    _class_call_check(this, WhisperProvider);
+    this.config = config;
+};
+var StableDiffusionProvider = function StableDiffusionProvider(config) {
+    _class_call_check(this, StableDiffusionProvider);
+    this.config = config;
+};
+var CharacterizationProvider = function CharacterizationProvider(config) {
+    _class_call_check(this, CharacterizationProvider);
+    this.config = config;
+};
+var RatingsProvider = function RatingsProvider(config) {
+    _class_call_check(this, RatingsProvider);
+    this.config = config;
+};
+var LoggerProvider = function LoggerProvider(config) {
+    _class_call_check(this, LoggerProvider);
+    this.config = config;
+};
+// src/sdk/providers/alquimia.ts
+var import_axios2 = __toESM(require("axios"));
+var AlquimiaWhisperProvider = /*#__PURE__*/ function(WhisperProvider) {
+    _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 = import_axios2.default.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 = import_axios2.default.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) {
+    _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,
+                                    import_axios2.default.post("".concat(path), data, {
+                                        headers: headers
+                                    })
+                                ];
+                            case 2:
+                                response = _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        success: true,
+                                        data: response.data
+                                    }
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                if (import_axios2.default.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
+var import_openai = __toESM(require("openai"));
+var OpenAIWhisperProvider = /*#__PURE__*/ function(WhisperProvider) {
+    _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) {
+    _inherits(OpenAIAnalyzeCharProvider, CharacterizationProvider);
+    function OpenAIAnalyzeCharProvider(config) {
+        _class_call_check(this, OpenAIAnalyzeCharProvider);
+        var _this;
+        _this = _call_super(this, OpenAIAnalyzeCharProvider, [
+            config
+        ]);
+        _this.client = new import_openai.default({
+            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) {
+    _inherits(OpenAIStableDiffusionProvider, StableDiffusionProvider);
+    function OpenAIStableDiffusionProvider(config) {
+        _class_call_check(this, OpenAIStableDiffusionProvider);
+        var _this;
+        _this = _call_super(this, OpenAIStableDiffusionProvider, [
+            config
+        ]);
+        _this.client = new import_openai.default({
+            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
+var import_buffer = require("buffer");
+var import_axios3 = __toESM(require("axios"));
+var StabilityProvider = /*#__PURE__*/ function(StableDiffusionProvider) {
+    _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,
+                                    import_axios3.default.postForm("https://api.stability.ai/v2beta/stable-image/generate/ultra", import_axios3.default.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 = import_buffer.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
+var import_elevenlabs = require("elevenlabs");
+var import_axios4 = __toESM(require("axios"));
+var requestSpecs = {
+    optimize_streaming_latency: import_elevenlabs.ElevenLabs.OptimizeStreamingLatency.Zero,
+    output_format: import_elevenlabs.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) {
+    _inherits(ElevenLabsWhisperProvider, WhisperProvider);
+    function ElevenLabsWhisperProvider(config) {
+        _class_call_check(this, ElevenLabsWhisperProvider);
+        var _this;
+        _this = _call_super(this, ElevenLabsWhisperProvider, [
+            config
+        ]);
+        _this.client = new import_elevenlabs.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 = import_axios4.default.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
+var import_pino = __toESM(require("pino"));
+var ElasticLoggerProvider = /*#__PURE__*/ function(LoggerProvider) {
+    _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([
+                                        Promise.resolve().then(function() {
+                                            return /*#__PURE__*/ _interop_require_wildcard(require("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 = (0, import_pino.default)({
+                                    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
+var import_react2 = require("react");
+// src/context/session-context.tsx
+var import_react = __toESM(require("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
+var import_idb = require("idb");
+var initialState = {
+    sessionId: null,
+    characterizationData: null
+};
+var AlquimiaContext = (0, import_react.createContext)(null);
+var useSessionContext = function() {
+    var context = (0, import_react.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 _ref = _sliced_to_array((0, import_react.useReducer)(characterizationReducer, initialState), 2), userSessionState = _ref[0], sessionDispatch = _ref[1];
+    (0, import_react.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,
+                            (0, import_idb.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,
+                            (0, import_idb.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__ */ import_react.default.createElement(AlquimiaContext.Provider, {
+        value: {
+            userSessionState: userSessionState,
+            getSessionData: getSessionData,
+            saveUserSession: saveUserSession
+        }
+    }, children);
+};
+// src/hooks/alquimia.hook.tsx
+function useAlquimia(sdk) {
+    var _ref = _sliced_to_array((0, import_react2.useState)(""), 2), chunkReceived = _ref[0], setChunkReceived = _ref[1];
+    var _ref1 = _sliced_to_array((0, import_react2.useState)(""), 2), currentMessageIdChuncked = _ref1[0], setCurrentMessageIdChuncked = _ref1[1];
+    var _ref2 = _sliced_to_array((0, import_react2.useState)(""), 2), input = _ref2[0], setInput = _ref2[1];
+    var _ref3 = _sliced_to_array((0, import_react2.useState)(false), 2), isLoading = _ref3[0], setIsLoading = _ref3[1];
+    var _ref4 = _sliced_to_array((0, import_react2.useState)(false), 2), isMessageStreaming = _ref4[0], setIsMessageStreaming = _ref4[1];
+    var _ref5 = _sliced_to_array((0, import_react2.useState)(null), 2), streamingMessageId = _ref5[0], setStreamingMessageId = _ref5[1];
+    var _ref6 = _sliced_to_array((0, import_react2.useState)(false), 2), isAudioRecording = _ref6[0], setIsAudioRecording = _ref6[1];
+    var _ref7 = _sliced_to_array((0, import_react2.useState)(null), 2), messageMetaData = _ref7[0], setMessageMetaData = _ref7[1];
+    var _ref8 = _sliced_to_array((0, import_react2.useState)([]), 2), messages = _ref8[0], setMessages = _ref8[1];
+    var _ref9 = _sliced_to_array((0, import_react2.useState)(null), 2), sessionId = _ref9[0], setSessionId = _ref9[1];
+    var _ref10 = _sliced_to_array((0, import_react2.useState)(null), 2), activeTool = _ref10[0], setActiveTool = _ref10[1];
+    var _ref11 = _sliced_to_array((0, import_react2.useState)(null), 2), lastRequest = _ref11[0], setLastRequest = _ref11[1];
+    var _useSessionContext = useSessionContext(), userSessionState = _useSessionContext.userSessionState, saveUserSession = _useSessionContext.saveUserSession;
+    var shouldShowCharacterizationButton = sdk.getEnforceCharacterization() && !(userSessionState === null || userSessionState === void 0 ? void 0 : userSessionState.characterizationData);
+    (0, import_react2.useEffect)(function() {
+        if (chunkReceived) processMessageChunk(currentMessageIdChuncked, chunkReceived);
+    }, [
+        chunkReceived
+    ]);
+    (0, import_react2.useEffect)(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
+var import_react3 = require("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 _ref = _sliced_to_array((0, import_react3.useState)(false), 2), isLoading = _ref[0], setIsLoading = _ref[1];
+    var _ref1 = _sliced_to_array((0, import_react3.useState)(false), 2), hasReviewed = _ref1[0], setHasReviewed = _ref1[1];
+    var _ref2 = _sliced_to_array((0, import_react3.useReducer)(ratingReducer, initialState2), 2), state = _ref2[0], dispatch = _ref2[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
+var import_crypto = require("crypto");
+var import_headers = require("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,
+                        (0, import_headers.cookies)()
+                    ];
+                case 1:
+                    cookieStore = _state.sent();
+                    if (!topicId) {
+                        conversationId = (0, import_crypto.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] = (0, import_crypto.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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+    AlquimiaRatingsProvider: AlquimiaRatingsProvider,
+    AlquimiaSDK: AlquimiaSDK,
+    AlquimiaWhisperProvider: AlquimiaWhisperProvider,
+    Button: Button,
+    Card: Card,
+    CharacterizationProvider: CharacterizationProvider,
+    Code: Code,
+    ElasticLoggerProvider: ElasticLoggerProvider,
+    ElevenLabsWhisperProvider: ElevenLabsWhisperProvider,
+    GenerativeProvider: GenerativeProvider,
+    LoggerProvider: LoggerProvider,
+    OpenAIAnalyzeCharProvider: OpenAIAnalyzeCharProvider,
+    OpenAIStableDiffusionProvider: OpenAIStableDiffusionProvider,
+    OpenAIWhisperProvider: OpenAIWhisperProvider,
+    RatingsProvider: RatingsProvider,
+    SessionProvider: SessionProvider,
+    StabilityProvider: StabilityProvider,
+    StableDiffusionProvider: StableDiffusionProvider,
+    WhisperProvider: WhisperProvider,
+    createMessageId: createMessageId,
+    createResource: createResource,
+    defineAssistantId: defineAssistantId,
+    deleteResource: deleteResource,
+    formatTimeWithUnit: formatTimeWithUnit,
+    generateHeaders: generateHeaders,
+    generateTranslatePrompt: generateTranslatePrompt,
+    getCookies: getCookies,
+    getQueryParam: getQueryParam,
+    getTopicSessionId: getTopicSessionId,
+    initConversation: initConversation,
+    isTextContent: isTextContent,
+    parseConversationsMapCookie: parseConversationsMapCookie,
+    readResource: readResource,
+    serializeAxiosError: serializeAxiosError,
+    updateResource: updateResource,
+    useAlquimia: useAlquimia,
+    useRatings: useRatings,
+    useSessionContext: useSessionContext
+});
+//# sourceMappingURL=index.js.map