@alquimia-ai/tools 1.0.2 → 1.0.5

package/dist/index.mjs

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