@alquimia-ai/tools 1.13.2 → 2.1.0

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  blobUploadRoute?: string;  // default: '/api/blob/upload'\n}\n\nexport function createNextJsAdapter(options?: NextJsAdapterOptions): AlquimiaAdapter {\n  const inferRoute = options?.inferRoute ?? '/api/chat';\n  const streamRoute = options?.streamRoute ?? '/api/stream';\n  const blobUploadRoute = options?.blobUploadRoute ?? '/api/blob/upload';\n\n  return {\n    resolveInferUrl(assistantId: string): string {\n      return `${inferRoute.replace(/\\/$/, '')}/${encodeURIComponent(assistantId)}`;\n    },\n    resolveStreamUrl(streamId: string): string {\n      return `${streamRoute}/${streamId}`;\n    },\n    resolveBlobUploadUrl(): string {\n      return blobUploadRoute;\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,WAAW,QAAQ,OAAO,EAAE,CAAC,IAAI,mBAAmB,WAAW,CAAC;AAAA,IAC5E;AAAA,IACA,iBAAiB,UAA0B;AACzC,aAAO,GAAG,WAAW,IAAI,QAAQ;AAAA,IACnC;AAAA,IACA,uBAA+B;AAC7B,aAAO;AAAA,IACT;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;
+        extraInstructions?: Record<string, string>;
+    };
+}
+declare function useAlquimia(config: UseAlquimiaConfig): {
+    sdk: AlquimiaSDK;
     activeTool: any;
     cleanMessages: () => void;
     createMessageId: typeof createMessageId;
@@ -22,20 +40,21 @@ 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;
     messages: AlquimiaMessage[];
     populateMessages: (messages: AlquimiaMessage[]) => void;
-    processMessageChunk: (messageId: string, chunk: string, error_code?: string, error_detail?: string, stream_id?: string, additionalInfo?: string, loading?: boolean, tooler?: ToolEvent[], thinkings?: any[]) => void;
+    processMessageChunk: (messageId: string, chunk: string, error_code?: string, error_detail?: string, taskid?: string, additionalInfo?: string, loading?: boolean, tooler?: ToolEvent[], thinkings?: any[]) => void;
     sendMessage: (message: string, callBack: (chunk: AIMessageChunk) => void, traceParentId?: string, sessionId?: string) => Promise<void>;
     sessionId: string | null;
     setActiveTool: react.Dispatch<any>;
     setSessionId: react.Dispatch<react.SetStateAction<string | null>>;
     setLastRequest: react.Dispatch<react.SetStateAction<string | null>>;
     setIsAudioRecording: react.Dispatch<react.SetStateAction<boolean>>;
-    evaluationStrategy: string;
     hasThinkings: boolean;
     attachments: File[];
     addAttachment: (file: File) => void;

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;
+        extraInstructions?: Record<string, string>;
+    };
+}
+declare function useAlquimia(config: UseAlquimiaConfig): {
+    sdk: AlquimiaSDK;
     activeTool: any;
     cleanMessages: () => void;
     createMessageId: typeof createMessageId;
@@ -22,20 +40,21 @@ 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;
     messages: AlquimiaMessage[];
     populateMessages: (messages: AlquimiaMessage[]) => void;
-    processMessageChunk: (messageId: string, chunk: string, error_code?: string, error_detail?: string, stream_id?: string, additionalInfo?: string, loading?: boolean, tooler?: ToolEvent[], thinkings?: any[]) => void;
+    processMessageChunk: (messageId: string, chunk: string, error_code?: string, error_detail?: string, taskid?: string, additionalInfo?: string, loading?: boolean, tooler?: ToolEvent[], thinkings?: any[]) => void;
     sendMessage: (message: string, callBack: (chunk: AIMessageChunk) => void, traceParentId?: string, sessionId?: string) => Promise<void>;
     sessionId: string | null;
     setActiveTool: react.Dispatch<any>;
     setSessionId: react.Dispatch<react.SetStateAction<string | null>>;
     setLastRequest: react.Dispatch<react.SetStateAction<string | null>>;
     setIsAudioRecording: react.Dispatch<react.SetStateAction<boolean>>;
-    evaluationStrategy: string;
     hasThinkings: boolean;
     attachments: File[];
     addAttachment: (file: File) => void;

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,224 @@ 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;
+    // Internal subscription id from infer (`taskid` on the wire).
+    this.streamId = null;
+    this.tools = [];
+    this.extraInstructions = null;
+    this.assistantConfig = null;
+    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;
+  }
+  withExtraInstructions(extraInstructions) {
+    this.extraInstructions = extraInstructions;
+    return this;
+  }
+  withAssistantConfig(assistantConfig) {
+    this.assistantConfig = assistantConfig;
+    return this;
+  }
+  withUserId(userId) {
+    this.userId = userId;
+    return this;
+  }
+  getEnforceCharacterization() {
+    return this.enforceCharacterization ?? true;
+  }
+  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 hasClientTools = Array.isArray(this.tools) && this.tools.length > 0;
+    const initMessage = {
+      query,
+      session_id: this.conversationId,
+      user_id: this.userId,
+      ...this.extraInstructions && { extra_instructions: this.extraInstructions },
+      ...this.assistantConfig && { config: this.assistantConfig },
+      ...hasClientTools && {
+        evaluation_strategy: {
+          evaluation_strategy_id: "native",
+          tool_schemas: this.tools
+        }
+      }
+    };
+    const result = (await this.axiosInstance.post(inferUrl, initMessage, {
+      headers: {
+        "Content-Type": "application/json",
+        "x-trace-parent": traceParent || "",
+        ...adapterHeaders,
+        ...this.buildIdentityHeaders()
+      }
+    })).data;
+    this.streamId = result.taskid ?? null;
+    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);
+  }
+  /**
+   * @deprecated The runtime no longer returns attachment IDs from the infer
+   * response — attachments are uploaded as standalone blobs and linked to the
+   * session via headers. Always returns `[]`; kept for source compatibility.
+   */
+  getAttachmentResponses() {
+    return this.attachmentResponses;
+  }
+  async uploadAttachment(file, _attachmentId) {
+    const url = this.adapter.resolveBlobUploadUrl();
+    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,
+        ...this.buildIdentityHeaders()
+      }
+    });
+  }
+  /**
+   * Identity headers (kebab-case) required by `/context/blob/upload` and
+   * the rest of the runtime's internal endpoints introduced in v0.2.0→next.
+   */
+  buildIdentityHeaders() {
+    const headers = {
+      "assistant-id": this.assistantId
+    };
+    if (this.conversationId) headers["session-id"] = this.conversationId;
+    if (this.userId) headers["user-id"] = this.userId;
+    if (this.streamId) headers["task-id"] = this.streamId;
+    return headers;
+  }
+  getUrlStream() {
+    if (!this.streamId) {
+      throw new Error("Stream ID not initialized. Call sendMessage() first");
+    }
+    return this.adapter.resolveStreamUrl(this.streamId);
+  }
+  getStreamId() {
+    return this.streamId;
+  }
+  /** Alias for {@link getStreamId} — same value as infer `taskid`. */
+  getTaskId() {
+    return this.streamId;
+  }
+};
+var alquimia_sdk_default = AlquimiaSDK;
+
 // src/utils/utils.ts
 function getCookies(name) {
   if (typeof document === "undefined") return void 0;
@@ -111,7 +339,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?.extraInstructions) instance.withExtraInstructions(config.options.extraInstructions);
+    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);
@@ -120,10 +361,10 @@ function useAlquimia(sdk) {
   const [isAudioRecording, setIsAudioRecording] = (0, import_react.useState)(false);
   const [messages, setMessages] = (0, import_react.useState)([]);
   const eventSourceRef = (0, import_react.useRef)(null);
+  const streamUserCancelledRef = (0, import_react.useRef)(false);
   const [sessionId, setSessionId] = (0, import_react.useState)(null);
   const [activeTool, setActiveTool] = (0, import_react.useState)(null);
   const [lastRequest, setLastRequest] = (0, import_react.useState)(null);
-  const [evaluationStrategy, setEvaluationStrategy] = (0, import_react.useState)("");
   const [hasThinkings, setHasThinkings] = (0, import_react.useState)(false);
   const [attachments, setAttachments] = (0, import_react.useState)([]);
   const [isUploadingAttachments, setIsUploadingAttachments] = (0, import_react.useState)(false);
@@ -144,11 +385,9 @@ function useAlquimia(sdk) {
   function clearAttachments() {
     setAttachments([]);
   }
-  function processMessageChunk(messageId, chunk, error_code, error_detail, stream_id, additionalInfo, loading, tooler, thinkings) {
+  function processMessageChunk(messageId, chunk, error_code, error_detail, taskid, 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 = {
@@ -158,14 +397,11 @@ function useAlquimia(sdk) {
           role: updatedMessages[messageIndex]?.role || "assistant",
           error_code,
           error_detail,
-          stream_id,
+          taskid,
           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 || []
@@ -182,7 +418,7 @@ function useAlquimia(sdk) {
             id: messageId,
             error_code,
             error_detail,
-            stream_id,
+            taskid,
             created_at: (/* @__PURE__ */ new Date()).getTime().toString(),
             loading,
             tooler: mergeToolEvents([], tooler),
@@ -204,7 +440,7 @@ function useAlquimia(sdk) {
           chunk?.answer || "",
           chunk?.error_code,
           chunk?.error_detail,
-          chunk?.stream_id,
+          chunk?.taskid,
           options?.additionalInfo,
           chunk?.loading,
           chunk?.tooler,
@@ -220,11 +456,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);
   }
@@ -248,6 +480,7 @@ function useAlquimia(sdk) {
     setMessages(messages2);
   }
   function handleLoadingCancel() {
+    streamUserCancelledRef.current = true;
     eventSourceRef.current?.close();
     eventSourceRef.current = null;
     setIsMessageLoading(false);
@@ -271,7 +504,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);
@@ -287,23 +520,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) {
@@ -311,9 +543,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);
@@ -332,6 +562,7 @@ function useAlquimia(sdk) {
       }
       const streamUrl = response.getUrlStream();
       const streamId = response.getStreamId() || "";
+      streamUserCancelledRef.current = false;
       const streamState = {
         streamId,
         connectedAt: Date.now(),
@@ -342,8 +573,6 @@ function useAlquimia(sdk) {
       };
       const eventSource = new EventSource(streamUrl);
       eventSourceRef.current = eventSource;
-      const evaluationStrategy2 = response.getEvaluationStrategy();
-      setEvaluationStrategy(evaluationStrategy2);
       eventSource.onopen = () => {
         streamState.openedAt = Date.now();
       };
@@ -354,23 +583,37 @@ function useAlquimia(sdk) {
       };
       eventSource.onerror = () => {
         if (streamState.closedByClient) return;
+        if (streamUserCancelledRef.current) {
+          streamUserCancelledRef.current = false;
+          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}`;
+          errorDetail = "Could not open the live response. Check your connection and try again.";
         } else if (streamState.messagesReceived === 0) {
-          errorDetail = `Stream connected but received no messages before error (open for ${elapsed}ms).`;
+          errorDetail = "No response was received. Try again in a moment.";
         } else {
-          errorDetail = `Stream dropped after ${streamState.messagesReceived} message(s), ${sinceLastMessage}ms since last message (total ${elapsed}ms). Possible timeout.`;
+          errorDetail = "The response was interrupted. Try again.";
+        }
+        if (typeof console !== "undefined" && console.debug) {
+          console.debug("[Alquimia] SSE transport error", {
+            streamUrl,
+            taskId: streamId,
+            opened: Boolean(streamState.openedAt),
+            messagesReceived: streamState.messagesReceived,
+            elapsedMs: elapsed,
+            sinceLastMessageMs: sinceLastMessage
+          });
         }
         callBack({
           type: "error",
           error_code: "STREAM_ERROR",
           error_detail: errorDetail,
-          stream_id: streamId
+          taskid: streamId
         });
       };
     } catch (error) {
@@ -381,13 +624,14 @@ function useAlquimia(sdk) {
       setStreamingMessageId(null);
       callBack({
         type: "error",
-        error_code: error.status?.toString() || "REQUEST_ERROR",
+        error_code: error.response?.status != null ? String(error.response.status) : "REQUEST_ERROR",
         error_detail: errMessage
       });
     }
   }
   function handleMessageEvent(event, callBack, eventSource, streamState) {
     const data = JSON.parse(event.data);
+    const eventTaskId = data.taskid || "";
     if (data.errors?.length) {
       for (const error of data.errors) {
         const detail = error.error_detail || (error.data != null ? `${error.data} (controlId: ${error.control_id})` : "Unknown error");
@@ -395,7 +639,7 @@ function useAlquimia(sdk) {
           type: "error",
           error_code: error.event_class || error.status || "UNKNOWN_ERROR",
           error_detail: detail,
-          stream_id: data.stream_id || ""
+          taskid: eventTaskId
         });
       }
       if (streamState) streamState.closedByClient = true;
@@ -403,31 +647,21 @@ function useAlquimia(sdk) {
       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" && typeof response.data === "string" ? response.data : null;
-    if (content) {
-      callBack({
-        type: "answer",
-        answer: content
-      });
+    if (data.event_class === "AssistantInferenceResponse") {
+      const final = data;
+      callBack({ type: "answer", answer: final.data });
       if (streamState) streamState.closedByClient = true;
       cleanup(false, eventSource);
     }
   }
   return {
+    sdk,
     activeTool,
     cleanMessages,
     createMessageId,
@@ -438,7 +672,9 @@ function useAlquimia(sdk) {
     handleLoadingCancel,
     input,
     isLoading,
+    isMessageLoading,
     isMessageStreaming,
+    isStreamingLoading,
     streamingMessageId,
     isAudioRecording,
     lastRequest,
@@ -451,7 +687,6 @@ function useAlquimia(sdk) {
     setSessionId,
     setLastRequest,
     setIsAudioRecording,
-    evaluationStrategy,
     hasThinkings,
     attachments,
     addAttachment,