@alquimia-ai/tools 1.13.1 → 2.0.1

package/dist/adapters/next.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/next.ts"],"sourcesContent":["import type { AlquimiaAdapter } from './index';\n\nexport interface NextJsAdapterOptions {\n  inferRoute?: string;      // default: '/api/chat'\n  streamRoute?: string;     // default: '/api/stream'\n  attachmentRoute?: string; // default: '/api/attachments'\n}\n\nexport function createNextJsAdapter(options?: NextJsAdapterOptions): AlquimiaAdapter {\n  const inferRoute = options?.inferRoute ?? '/api/chat';\n  const streamRoute = options?.streamRoute ?? '/api/stream';\n  const attachmentRoute = options?.attachmentRoute ?? '/api/attachments';\n\n  return {\n    resolveInferUrl(assistantId: string): string {\n      return `${inferRoute}/chat/${assistantId}`;\n    },\n    resolveStreamUrl(streamId: string): string {\n      return `${streamRoute}/${streamId}`;\n    },\n    resolveAttachmentUrl(streamId: string, attachmentId: string): string {\n      return `${attachmentRoute}/${streamId}/${attachmentId}`;\n    },\n  };\n}\n"],"mappings":";AAQO,SAAS,oBAAoB,SAAiD;AACnF,QAAM,aAAa,SAAS,cAAc;AAC1C,QAAM,cAAc,SAAS,eAAe;AAC5C,QAAM,kBAAkB,SAAS,mBAAmB;AAEpD,SAAO;AAAA,IACL,gBAAgB,aAA6B;AAC3C,aAAO,GAAG,UAAU,SAAS,WAAW;AAAA,IAC1C;AAAA,IACA,iBAAiB,UAA0B;AACzC,aAAO,GAAG,WAAW,IAAI,QAAQ;AAAA,IACnC;AAAA,IACA,qBAAqB,UAAkB,cAA8B;AACnE,aAAO,GAAG,eAAe,IAAI,QAAQ,IAAI,YAAY;AAAA,IACvD;AAAA,EACF;AACF;","names":[]}

package/dist/hooks/index.d.mts

@@ -1,12 +1,30 @@
 import * as react from 'react';
 import { AlquimiaSDK } from '../sdk/index.mjs';
+import { AlquimiaAdapter } from '../adapters/index.mjs';
+import { W as WhisperProvider, S as StableDiffusionProvider, C as CharacterizationProvider, R as RatingsProvider, L as LoggerProvider } from '../providers-0Gi78uNQ.mjs';
 import { AlquimiaMessage, ToolEvent, AIMessageChunk, RatingData } from '../types/index.mjs';
 import { createMessageId } from '../utils/index.mjs';
-import '../providers-0Gi78uNQ.mjs';
 import '@elastic/apm-rum';
 import 'ai';
 
-declare function useAlquimia(sdk: AlquimiaSDK): {
+interface UseAlquimiaConfig {
+    assistantId: string;
+    adapter: AlquimiaAdapter;
+    providers?: {
+        whisper?: WhisperProvider;
+        stableDiffusion?: StableDiffusionProvider;
+        characterization?: CharacterizationProvider;
+        ratings?: RatingsProvider;
+        logger?: LoggerProvider;
+    };
+    options?: {
+        enforceCharacterization?: boolean;
+        userId?: string;
+        extraData?: any;
+    };
+}
+declare function useAlquimia(config: UseAlquimiaConfig): {
+    sdk: AlquimiaSDK;
     activeTool: any;
     cleanMessages: () => void;
     createMessageId: typeof createMessageId;
@@ -22,7 +40,9 @@ declare function useAlquimia(sdk: AlquimiaSDK): {
     handleLoadingCancel: () => void;
     input: string;
     isLoading: boolean;
+    isMessageLoading: boolean;
     isMessageStreaming: boolean;
+    isStreamingLoading: boolean;
     streamingMessageId: string | null;
     isAudioRecording: boolean;
     lastRequest: string | null;

package/dist/hooks/index.d.ts

@@ -1,12 +1,30 @@
 import * as react from 'react';
 import { AlquimiaSDK } from '../sdk/index.js';
+import { AlquimiaAdapter } from '../adapters/index.js';
+import { W as WhisperProvider, S as StableDiffusionProvider, C as CharacterizationProvider, R as RatingsProvider, L as LoggerProvider } from '../providers-BJTXCtI3.js';
 import { AlquimiaMessage, ToolEvent, AIMessageChunk, RatingData } from '../types/index.js';
 import { createMessageId } from '../utils/index.js';
-import '../providers-BJTXCtI3.js';
 import '@elastic/apm-rum';
 import 'ai';
 
-declare function useAlquimia(sdk: AlquimiaSDK): {
+interface UseAlquimiaConfig {
+    assistantId: string;
+    adapter: AlquimiaAdapter;
+    providers?: {
+        whisper?: WhisperProvider;
+        stableDiffusion?: StableDiffusionProvider;
+        characterization?: CharacterizationProvider;
+        ratings?: RatingsProvider;
+        logger?: LoggerProvider;
+    };
+    options?: {
+        enforceCharacterization?: boolean;
+        userId?: string;
+        extraData?: any;
+    };
+}
+declare function useAlquimia(config: UseAlquimiaConfig): {
+    sdk: AlquimiaSDK;
     activeTool: any;
     cleanMessages: () => void;
     createMessageId: typeof createMessageId;
@@ -22,7 +40,9 @@ declare function useAlquimia(sdk: AlquimiaSDK): {
     handleLoadingCancel: () => void;
     input: string;
     isLoading: boolean;
+    isMessageLoading: boolean;
     isMessageStreaming: boolean;
+    isStreamingLoading: boolean;
     streamingMessageId: string | null;
     isAudioRecording: boolean;
     lastRequest: string | null;

package/dist/hooks/index.js

@@ -1,7 +1,9 @@
 "use strict";
+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 = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (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 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/hooks/index.ts
@@ -28,6 +38,205 @@ module.exports = __toCommonJS(hooks_exports);
 // src/hooks/alquimia.hook.tsx
 var import_react = require("react");
 
+// src/sdk/alquimia-sdk.ts
+var import_axios = __toESM(require("axios"));
+var AlquimiaSDK = class {
+  constructor(assistantId, adapter, options = {}) {
+    this.conversationId = null;
+    this.sessionId = null;
+    this.streamId = null;
+    this.evaluationStrategy = null;
+    this.tools = [];
+    this.extraData = null;
+    this.assistantConfig = null;
+    this.forceProfile = {};
+    this.userId = null;
+    this.attachments = [];
+    this.attachmentResponses = [];
+    if (!assistantId) {
+      throw new Error("AlquimiaSDK: assistantId is required");
+    }
+    if (!adapter) {
+      throw new Error(
+        "AlquimiaSDK: adapter is required. Use createNextJsAdapter() or createFetchAdapter()"
+      );
+    }
+    this.assistantId = assistantId;
+    this.adapter = adapter;
+    this.enforceCharacterization = options.enforceCharacterization ?? true;
+    this.axiosInstance = import_axios.default.create();
+    this.axiosInstance.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error.response?.status && 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);
+  }
+  withConversationId(conversationId) {
+    this.conversationId = conversationId;
+    return this;
+  }
+  withAttachments(attachments) {
+    this.attachments = attachments;
+    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;
+  }
+  withTools(tools) {
+    this.tools = tools;
+    return this;
+  }
+  withExtraData(extraData) {
+    this.extraData = extraData;
+    return this;
+  }
+  withForceProfile(forceProfile) {
+    this.forceProfile = forceProfile;
+    return this;
+  }
+  withAssistantConfig(assistantConfig) {
+    this.assistantConfig = assistantConfig;
+    return this;
+  }
+  withUserId(userId) {
+    this.userId = userId;
+    return this;
+  }
+  getEnforceCharacterization() {
+    return this.enforceCharacterization ?? true;
+  }
+  getEvaluationStrategy() {
+    return this.evaluationStrategy;
+  }
+  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. Call withConversationId() before sendMessage()"
+      );
+    }
+    const inferUrl = this.adapter.resolveInferUrl(this.assistantId);
+    const adapterHeaders = this.adapter.getHeaders?.() ?? {};
+    const initMessage = {
+      query,
+      session_id: this.conversationId,
+      ...this.extraData && { extra_data: this.extraData },
+      force_profile: this.forceProfile,
+      ...this.assistantConfig && { config: this.assistantConfig },
+      tools: this.tools,
+      user_id: this.userId,
+      attachments: this.attachments
+    };
+    const result = (await this.axiosInstance.post(inferUrl, initMessage, {
+      headers: {
+        "Content-Type": "application/json",
+        "x-trace-parent": traceParent || "",
+        ...adapterHeaders
+      }
+    })).data;
+    this.evaluationStrategy = result?.config?.dante?.profile?.evaluation_strategy?.evaluation_strategy_id ?? null;
+    this.streamId = result.stream_id;
+    this.attachmentResponses = result.attachments ?? [];
+    this.attachments = [];
+    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);
+  }
+  getAttachmentResponses() {
+    return this.attachmentResponses;
+  }
+  async uploadAttachment(file, attachmentId) {
+    if (!this.streamId || !attachmentId) {
+      throw new Error("Stream or attachment ID not initialized");
+    }
+    const url = this.adapter.resolveAttachmentUrl(this.streamId, attachmentId);
+    const adapterHeaders = this.adapter.getHeaders?.() ?? {};
+    const formData = new FormData();
+    formData.append("file", file);
+    await this.axiosInstance.post(url, formData, {
+      headers: { "Content-Type": "multipart/form-data", ...adapterHeaders }
+    });
+  }
+  getUrlStream() {
+    if (!this.streamId) {
+      throw new Error("Stream ID not initialized. Call sendMessage() first");
+    }
+    return this.adapter.resolveStreamUrl(this.streamId);
+  }
+  getStreamId() {
+    return this.streamId;
+  }
+};
+var alquimia_sdk_default = AlquimiaSDK;
+
 // src/utils/utils.ts
 function getCookies(name) {
   if (typeof document === "undefined") return void 0;
@@ -65,22 +274,6 @@ function mergeThinkingsByControlId(existingThinkings = [], newThinkings = []) {
   }
   return Array.from(thinkingsMap.values());
 }
-function extractAnswerContent(content) {
-  if (typeof content !== "string") return "";
-  const trimmed = content.trim();
-  if (trimmed.startsWith("{")) {
-    try {
-      const repaired = trimmed.replace(/(?<!\\)\n/g, "\\n");
-      const parsed = JSON.parse(repaired);
-      if (parsed && typeof parsed === "object" && "answer" in parsed) {
-        return parsed.answer;
-      }
-    } catch (e) {
-      return content;
-    }
-  }
-  return content;
-}
 function mergeToolerByControlId(currentTooler, toolEvent) {
   const { event_class, control_id, data, status } = toolEvent;
   const existingTool = currentTooler.find((t) => t.control_id === control_id);
@@ -127,7 +320,20 @@ function mergeToolEvents(initial, toolEvents) {
 }
 
 // src/hooks/alquimia.hook.tsx
-function useAlquimia(sdk) {
+function useAlquimia(config) {
+  const sdk = (0, import_react.useMemo)(() => {
+    const instance = new alquimia_sdk_default(config.assistantId, config.adapter, {
+      enforceCharacterization: config.options?.enforceCharacterization
+    });
+    if (config.providers?.whisper) instance.withWhisperProvider(config.providers.whisper);
+    if (config.providers?.stableDiffusion) instance.withStableDiffusionProvider(config.providers.stableDiffusion);
+    if (config.providers?.characterization) instance.withAnalyzeCharacterizationProvider(config.providers.characterization);
+    if (config.providers?.ratings) instance.withRatingsProvider(config.providers.ratings);
+    if (config.providers?.logger) instance.withLoggerProvider(config.providers.logger);
+    if (config.options?.userId) instance.withUserId(config.options.userId);
+    if (config.options?.extraData) instance.withExtraData(config.options.extraData);
+    return instance;
+  }, [config.assistantId, config.adapter]);
   const [input, setInput] = (0, import_react.useState)("");
   const [isMessageLoading, setIsMessageLoading] = (0, import_react.useState)(false);
   const [isStreamingLoading, setIsStreamingLoading] = (0, import_react.useState)(false);
@@ -162,9 +368,7 @@ function useAlquimia(sdk) {
   }
   function processMessageChunk(messageId, chunk, error_code, error_detail, stream_id, additionalInfo, loading, tooler, thinkings) {
     setMessages((currentMessages) => {
-      const messageIndex = currentMessages.findIndex(
-        (message) => message?.id === messageId
-      );
+      const messageIndex = currentMessages.findIndex((message) => message?.id === messageId);
       if (messageIndex !== -1) {
         const updatedMessages = [...currentMessages];
         const updatedMessage = {
@@ -178,10 +382,7 @@ function useAlquimia(sdk) {
           additionalInfo,
           created_at: (/* @__PURE__ */ new Date()).getTime().toString(),
           loading,
-          tooler: mergeToolEvents(
-            updatedMessages[messageIndex]?.tooler || [],
-            tooler
-          ),
+          tooler: mergeToolEvents(updatedMessages[messageIndex]?.tooler || [], tooler),
           thinkings: mergeThinkingsByControlId(
             updatedMessages[messageIndex]?.thinkings || [],
             thinkings || []
@@ -236,11 +437,7 @@ function useAlquimia(sdk) {
     setIsMessageLoading(true);
     event.preventDefault();
     if (input) {
-      await processAndSendMessage(input, {
-        traceParentId,
-        sessionId: sessionId2,
-        additionalInfo
-      });
+      await processAndSendMessage(input, { traceParentId, sessionId: sessionId2, additionalInfo });
     }
     setIsMessageLoading(false);
   }
@@ -287,7 +484,7 @@ function useAlquimia(sdk) {
   }
   function getCookie(name) {
     const cookies = document.cookie.split(";");
-    for (let cookie of cookies) {
+    for (const cookie of cookies) {
       const [cookieName, cookieValue] = cookie.trim().split("=");
       if (cookieName === name) {
         return decodeURIComponent(cookieValue);
@@ -303,23 +500,22 @@ function useAlquimia(sdk) {
   }
   async function sendMessage(message, callBack, traceParentId, sessionId2) {
     setIsStreamingLoading(true);
-    callBack({
-      type: "loading",
-      loading: true
-    });
+    callBack({ type: "loading", loading: true });
     const conversationId = sessionId2 || getCookie("alquimia-session");
     setIsMessageStreaming(true);
     setActiveTool(null);
     setLastRequest(message);
     try {
       const hasAttachments = attachments.length > 0;
-      const sdkCall = sdk.widthConversationId(conversationId || "");
+      const sdkCall = sdk.withConversationId(conversationId || "");
       if (hasAttachments) {
-        sdkCall.withAttachments(attachments.map((f) => ({
-          filename: f.name,
-          content_type: f.type,
-          content_size: f.size
-        })));
+        sdkCall.withAttachments(
+          attachments.map((f) => ({
+            filename: f.name,
+            content_type: f.type,
+            content_size: f.size
+          }))
+        );
       }
       const response = await sdkCall.sendMessage(message, traceParentId);
       if (hasAttachments) {
@@ -327,9 +523,7 @@ function useAlquimia(sdk) {
         try {
           const attachmentResponses = response.getAttachmentResponses();
           await Promise.all(
-            attachments.map(
-              (file, i) => response.uploadAttachment(file, attachmentResponses[i])
-            )
+            attachments.map((file, i) => response.uploadAttachment(file, attachmentResponses[i]))
           );
         } catch (uploadError) {
           setIsUploadingAttachments(false);
@@ -346,19 +540,47 @@ function useAlquimia(sdk) {
         setIsUploadingAttachments(false);
         clearAttachments();
       }
-      const eventSource = new EventSource(response.getUrlStream());
+      const streamUrl = response.getUrlStream();
+      const streamId = response.getStreamId() || "";
+      const streamState = {
+        streamId,
+        connectedAt: Date.now(),
+        openedAt: null,
+        messagesReceived: 0,
+        lastMessageAt: null,
+        closedByClient: false
+      };
+      const eventSource = new EventSource(streamUrl);
       eventSourceRef.current = eventSource;
       const evaluationStrategy2 = response.getEvaluationStrategy();
       setEvaluationStrategy(evaluationStrategy2);
-      eventSource.onmessage = (event) => handleMessageEvent(event, callBack, eventSource);
-      eventSource.onerror = (event) => {
-        console.error("Stream connection error", event);
+      eventSource.onopen = () => {
+        streamState.openedAt = Date.now();
+      };
+      eventSource.onmessage = (event) => {
+        streamState.messagesReceived++;
+        streamState.lastMessageAt = Date.now();
+        handleMessageEvent(event, callBack, eventSource, streamState);
+      };
+      eventSource.onerror = () => {
+        if (streamState.closedByClient) return;
+        streamState.closedByClient = true;
+        const elapsed = Date.now() - streamState.connectedAt;
+        const sinceLastMessage = streamState.lastMessageAt ? Date.now() - streamState.lastMessageAt : null;
         cleanup(false, eventSource);
+        let errorDetail;
+        if (!streamState.openedAt) {
+          errorDetail = `Stream failed to connect (after ${elapsed}ms). URL: ${streamUrl}`;
+        } else if (streamState.messagesReceived === 0) {
+          errorDetail = `Stream connected but received no messages before error (open for ${elapsed}ms).`;
+        } else {
+          errorDetail = `Stream dropped after ${streamState.messagesReceived} message(s), ${sinceLastMessage}ms since last message (total ${elapsed}ms). Possible timeout.`;
+        }
         callBack({
           type: "error",
           error_code: "STREAM_ERROR",
-          error_detail: "Failed to establish stream connection. Stream event source error.",
-          stream_id: response.getStreamId() || ""
+          error_detail: errorDetail,
+          stream_id: streamId
         });
       };
     } catch (error) {
@@ -374,46 +596,39 @@ function useAlquimia(sdk) {
       });
     }
   }
-  function handleMessageEvent(event, callBack, eventSource) {
+  function handleMessageEvent(event, callBack, eventSource, streamState) {
     const data = JSON.parse(event.data);
     if (data.errors?.length) {
       for (const error of data.errors) {
-        console.error("Stream error:", error);
+        const detail = error.error_detail || (error.data != null ? `${error.data} (controlId: ${error.control_id})` : "Unknown error");
         callBack({
           type: "error",
           error_code: error.event_class || error.status || "UNKNOWN_ERROR",
-          error_detail: `${error.data}, controlId: ${error.control_id}` || error.error_detail || "Unknown error",
+          error_detail: detail,
           stream_id: data.stream_id || ""
         });
       }
+      if (streamState) streamState.closedByClient = true;
       cleanup(false, eventSource);
       return;
     }
     if (data.tools_output?.length) {
-      callBack({
-        type: "answer",
-        answer: "",
-        tooler: data.tools_output
-      });
+      callBack({ type: "answer", answer: "", tooler: data.tools_output });
     }
     if (data.thinkings?.length) {
       setHasThinkings(true);
-      callBack({
-        type: "answer",
-        thinkings: data.thinkings
-      });
+      callBack({ type: "answer", thinkings: data.thinkings });
     }
     const response = data.response;
-    const content = response?.event_class === "AssistantInferenceResponse" ? extractAnswerContent(response?.data?.content) : null;
+    const content = response?.event_class === "AssistantInferenceResponse" && typeof response.data === "string" ? response.data : null;
     if (content) {
-      callBack({
-        type: "answer",
-        answer: content
-      });
+      callBack({ type: "answer", answer: content });
+      if (streamState) streamState.closedByClient = true;
       cleanup(false, eventSource);
     }
   }
   return {
+    sdk,
     activeTool,
     cleanMessages,
     createMessageId,
@@ -424,7 +639,9 @@ function useAlquimia(sdk) {
     handleLoadingCancel,
     input,
     isLoading,
+    isMessageLoading,
     isMessageStreaming,
+    isStreamingLoading,
     streamingMessageId,
     isAudioRecording,
     lastRequest,