@alquimia-ai/tools 2.0.1 → 2.2.0

package/dist/hooks/index.d.ts

@@ -4,6 +4,7 @@ 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 { W as WorklogState } from '../types-CIqszY3g.js';
 import '@elastic/apm-rum';
 import 'ai';
 
@@ -20,7 +21,8 @@ interface UseAlquimiaConfig {
     options?: {
         enforceCharacterization?: boolean;
         userId?: string;
-        extraData?: any;
+        extraInstructions?: Record<string, string>;
+        worklog?: boolean;
     };
 }
 declare function useAlquimia(config: UseAlquimiaConfig): {
@@ -48,15 +50,15 @@ declare function useAlquimia(config: UseAlquimiaConfig): {
     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;
+    worklog: WorklogState | undefined;
     attachments: File[];
     addAttachment: (file: File) => void;
     addAttachments: (files: File[]) => void;

package/dist/hooks/index.js

@@ -36,7 +36,7 @@ __export(hooks_exports, {
 module.exports = __toCommonJS(hooks_exports);
 
 // src/hooks/alquimia.hook.tsx
-var import_react = require("react");
+var import_react2 = require("react");
 
 // src/sdk/alquimia-sdk.ts
 var import_axios = __toESM(require("axios"));
@@ -44,12 +44,11 @@ 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.evaluationStrategy = null;
     this.tools = [];
-    this.extraData = null;
+    this.extraInstructions = null;
     this.assistantConfig = null;
-    this.forceProfile = {};
     this.userId = null;
     this.attachments = [];
     this.attachmentResponses = [];
@@ -115,12 +114,8 @@ var AlquimiaSDK = class {
     this.tools = tools;
     return this;
   }
-  withExtraData(extraData) {
-    this.extraData = extraData;
-    return this;
-  }
-  withForceProfile(forceProfile) {
-    this.forceProfile = forceProfile;
+  withExtraInstructions(extraInstructions) {
+    this.extraInstructions = extraInstructions;
     return this;
   }
   withAssistantConfig(assistantConfig) {
@@ -134,9 +129,6 @@ var AlquimiaSDK = class {
   getEnforceCharacterization() {
     return this.enforceCharacterization ?? true;
   }
-  getEvaluationStrategy() {
-    return this.evaluationStrategy;
-  }
   textToSpeech(text) {
     if (!this.whisperProvider) {
       throw new Error("Whisper provider not initialized");
@@ -157,25 +149,29 @@ var AlquimiaSDK = class {
     }
     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,
-      ...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
+      ...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
+        ...adapterHeaders,
+        ...this.buildIdentityHeaders()
       }
     })).data;
-    this.evaluationStrategy = result?.config?.dante?.profile?.evaluation_strategy?.evaluation_strategy_id ?? null;
-    this.streamId = result.stream_id;
+    this.streamId = result.taskid ?? null;
     this.attachmentResponses = result.attachments ?? [];
     this.attachments = [];
     return this;
@@ -210,21 +206,40 @@ var AlquimiaSDK = class {
     }
     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) {
-    if (!this.streamId || !attachmentId) {
-      throw new Error("Stream or attachment ID not initialized");
-    }
-    const url = this.adapter.resolveAttachmentUrl(this.streamId, attachmentId);
+  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 }
+      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");
@@ -234,6 +249,10 @@ var AlquimiaSDK = class {
   getStreamId() {
     return this.streamId;
   }
+  /** Alias for {@link getStreamId} — same value as infer `taskid`. */
+  getTaskId() {
+    return this.streamId;
+  }
 };
 var alquimia_sdk_default = AlquimiaSDK;
 
@@ -319,9 +338,169 @@ function mergeToolEvents(initial, toolEvents) {
   );
 }
 
+// src/worklog/types.ts
+function initialWorklogState(taskId = null) {
+  return { taskId, status: "idle", answer: null, nodes: [], index: {}, raw: [] };
+}
+
+// src/worklog/registry.ts
+var asRecord = (data) => data && typeof data === "object" ? data : {};
+var toolTitle = (r) => {
+  const name = asRecord(r.data).name;
+  return typeof name === "string" && name.length > 0 ? `Tool: ${name}` : "Tool";
+};
+var agentTitle = (r) => {
+  const name = asRecord(r.data).name;
+  return typeof name === "string" && name.length > 0 ? `Agent: ${name}` : "Agent-to-agent";
+};
+var constTitle = (label) => () => label;
+var EVENT_REGISTRY = {
+  // Run envelope
+  AssistantInference: { kind: "answer", role: "run-open", title: constTitle("Inference started") },
+  AssistantInferenceResponse: { kind: "answer", role: "run-close", title: constTitle("Answer") },
+  // Safeguard
+  ShieldInference: { kind: "safeguard", role: "open", title: constTitle("Safeguard") },
+  ShieldInferenceResponse: { kind: "safeguard", role: "close", title: constTitle("Safeguard") },
+  // Reasoning
+  ResponseInference: { kind: "reasoning", role: "open", title: constTitle("Reasoning") },
+  ResponseInferenceResponse: { kind: "reasoning", role: "close", title: constTitle("Reasoning") },
+  // Tools (server + subclasses) and their responses
+  ServerToolExecution: { kind: "tool", role: "open", title: toolTitle },
+  BuiltinToolExecution: { kind: "tool", role: "open", title: toolTitle },
+  UnknownToolExecution: { kind: "tool", role: "open", title: toolTitle },
+  ClientToolExecution: { kind: "tool", role: "open", title: toolTitle, pending: true },
+  ToolExecutionResponse: { kind: "tool", role: "close", title: toolTitle },
+  BuiltinToolExecutionResponse: { kind: "tool", role: "close", title: toolTitle },
+  // Tool schema discovery
+  ToolSchema: { kind: "tool", role: "open", title: constTitle("Tool schema") },
+  ToolSchemaResponse: { kind: "tool", role: "close", title: constTitle("Tool schema") },
+  // Agent-to-agent
+  A2AInference: { kind: "a2a", role: "open", title: agentTitle },
+  AgentDiscovery: { kind: "a2a", role: "open", title: constTitle("Agent discovery") },
+  AgentDiscoveryResponse: { kind: "a2a", role: "close", title: constTitle("Agent discovery") },
+  // Memory / persistence
+  ContextPersistence: { kind: "memory", role: "open", title: constTitle("Memory persistence") },
+  ContextFlush: { kind: "memory", role: "open", title: constTitle("Memory flush") },
+  ContextFlushResponse: { kind: "memory", role: "close", title: constTitle("Memory flush") },
+  // Human approval
+  HumanApprovalRequired: {
+    kind: "tool",
+    role: "open",
+    title: constTitle("Human approval required"),
+    pending: true
+  },
+  HumanApprovalRequiredResponse: { kind: "tool", role: "close", title: constTitle("Human approval") }
+};
+function resolveInterpreter(eventClass) {
+  if (Object.prototype.hasOwnProperty.call(EVENT_REGISTRY, eventClass)) {
+    return EVENT_REGISTRY[eventClass];
+  }
+  return {
+    kind: "unknown",
+    role: "open",
+    title: (r) => r.event_class
+  };
+}
+
+// src/worklog/reducer.ts
+var asString = (v) => typeof v === "string" ? v : v == null ? "" : JSON.stringify(v);
+var nodeDepth = (record) => {
+  const d = record.data && typeof record.data === "object" ? record.data.depth : void 0;
+  return typeof d === "number" ? d : 0;
+};
+var makeOpenNode = (record, interp, id) => ({
+  id,
+  kind: interp.kind,
+  eventClass: record.event_class,
+  status: interp.pending ? "pending" : "running",
+  title: interp.title(record),
+  startedAt: record.date_submitted,
+  depth: nodeDepth(record),
+  children: [],
+  command: record.data,
+  raw: [record]
+});
+var makeClosedNode = (record, interp, id) => ({
+  id,
+  kind: interp.kind,
+  eventClass: record.event_class,
+  status: record.status === "error" ? "failed" : "completed",
+  title: interp.title(record),
+  startedAt: record.date_submitted,
+  endedAt: record.date_submitted,
+  depth: nodeDepth(record),
+  children: [],
+  response: record.data,
+  error: record.status === "error" ? asString(record.data) : void 0,
+  raw: [record]
+});
+function reduceWorklog(state, record) {
+  const interp = resolveInterpreter(record.event_class);
+  const next = {
+    ...state,
+    nodes: state.nodes.slice(),
+    index: { ...state.index },
+    raw: [...state.raw, record]
+  };
+  if (interp.role === "ignore") return next;
+  if (interp.role === "run-open") {
+    next.status = "running";
+    return next;
+  }
+  if (interp.role === "run-close") {
+    next.answer = asString(record.data) || null;
+    next.status = record.status === "error" ? "error" : "success";
+    return next;
+  }
+  const key = record.control_id ?? `${record.event_class}-${next.raw.length}`;
+  if (interp.role === "close") {
+    const pos2 = Object.prototype.hasOwnProperty.call(next.index, key) ? next.index[key] : void 0;
+    if (pos2 != null) {
+      const existing = next.nodes[pos2];
+      next.nodes[pos2] = {
+        ...existing,
+        status: record.status === "error" ? "failed" : "completed",
+        endedAt: record.date_submitted,
+        response: record.data,
+        error: record.status === "error" ? asString(record.data) : existing.error,
+        raw: [...existing.raw, record]
+      };
+    } else {
+      next.index[key] = next.nodes.length;
+      next.nodes.push(makeClosedNode(record, interp, key));
+    }
+    if (record.status === "error") next.status = "error";
+    return next;
+  }
+  const pos = Object.prototype.hasOwnProperty.call(next.index, key) ? next.index[key] : void 0;
+  if (pos != null) {
+    const existing = next.nodes[pos];
+    next.nodes[pos] = { ...existing, raw: [...existing.raw, record] };
+  } else {
+    next.index[key] = next.nodes.length;
+    next.nodes.push(makeOpenNode(record, interp, key));
+  }
+  return next;
+}
+
+// src/worklog/use-worklog.ts
+var import_react = require("react");
+
+// src/worklog/from-frame.ts
+function frameToRecord(frame) {
+  const status = frame.status === "success" || frame.status === "error" ? frame.status : null;
+  return {
+    event_class: typeof frame.event_class === "string" && frame.event_class.length > 0 ? frame.event_class : "Unknown",
+    control_id: frame.control_id ?? null,
+    data: frame.data,
+    status,
+    date_submitted: typeof frame.date_submitted === "string" ? frame.date_submitted : ""
+  };
+}
+
 // src/hooks/alquimia.hook.tsx
 function useAlquimia(config) {
-  const sdk = (0, import_react.useMemo)(() => {
+  const sdk = (0, import_react2.useMemo)(() => {
     const instance = new alquimia_sdk_default(config.assistantId, config.adapter, {
       enforceCharacterization: config.options?.enforceCharacterization
     });
@@ -331,24 +510,28 @@ function useAlquimia(config) {
     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);
+    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);
-  const [isMessageStreaming, setIsMessageStreaming] = (0, import_react.useState)(false);
-  const [streamingMessageId, setStreamingMessageId] = (0, import_react.useState)(null);
-  const [isAudioRecording, setIsAudioRecording] = (0, import_react.useState)(false);
-  const [messages, setMessages] = (0, import_react.useState)([]);
-  const eventSourceRef = (0, import_react.useRef)(null);
-  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);
+  const [input, setInput] = (0, import_react2.useState)("");
+  const [isMessageLoading, setIsMessageLoading] = (0, import_react2.useState)(false);
+  const [isStreamingLoading, setIsStreamingLoading] = (0, import_react2.useState)(false);
+  const [isMessageStreaming, setIsMessageStreaming] = (0, import_react2.useState)(false);
+  const [streamingMessageId, setStreamingMessageId] = (0, import_react2.useState)(null);
+  const [isAudioRecording, setIsAudioRecording] = (0, import_react2.useState)(false);
+  const [messages, setMessages] = (0, import_react2.useState)([]);
+  const eventSourceRef = (0, import_react2.useRef)(null);
+  const streamUserCancelledRef = (0, import_react2.useRef)(false);
+  const [sessionId, setSessionId] = (0, import_react2.useState)(null);
+  const [activeTool, setActiveTool] = (0, import_react2.useState)(null);
+  const [lastRequest, setLastRequest] = (0, import_react2.useState)(null);
+  const [hasThinkings, setHasThinkings] = (0, import_react2.useState)(false);
+  const worklogEnabled = config.options?.worklog ?? false;
+  const [worklog, setWorklog] = (0, import_react2.useState)(
+    worklogEnabled ? initialWorklogState() : void 0
+  );
+  const [attachments, setAttachments] = (0, import_react2.useState)([]);
+  const [isUploadingAttachments, setIsUploadingAttachments] = (0, import_react2.useState)(false);
   const isLoading = isMessageLoading || isStreamingLoading || isUploadingAttachments;
   function cleanMessages() {
     setMessages([]);
@@ -366,7 +549,7 @@ function useAlquimia(config) {
   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);
       if (messageIndex !== -1) {
@@ -378,7 +561,7 @@ function useAlquimia(config) {
           role: updatedMessages[messageIndex]?.role || "assistant",
           error_code,
           error_detail,
-          stream_id,
+          taskid,
           additionalInfo,
           created_at: (/* @__PURE__ */ new Date()).getTime().toString(),
           loading,
@@ -399,7 +582,7 @@ function useAlquimia(config) {
             id: messageId,
             error_code,
             error_detail,
-            stream_id,
+            taskid,
             created_at: (/* @__PURE__ */ new Date()).getTime().toString(),
             loading,
             tooler: mergeToolEvents([], tooler),
@@ -421,7 +604,7 @@ function useAlquimia(config) {
           chunk?.answer || "",
           chunk?.error_code,
           chunk?.error_detail,
-          chunk?.stream_id,
+          chunk?.taskid,
           options?.additionalInfo,
           chunk?.loading,
           chunk?.tooler,
@@ -461,6 +644,7 @@ function useAlquimia(config) {
     setMessages(messages2);
   }
   function handleLoadingCancel() {
+    streamUserCancelledRef.current = true;
     eventSourceRef.current?.close();
     eventSourceRef.current = null;
     setIsMessageLoading(false);
@@ -542,6 +726,7 @@ function useAlquimia(config) {
       }
       const streamUrl = response.getUrlStream();
       const streamId = response.getStreamId() || "";
+      streamUserCancelledRef.current = false;
       const streamState = {
         streamId,
         connectedAt: Date.now(),
@@ -550,10 +735,9 @@ function useAlquimia(config) {
         lastMessageAt: null,
         closedByClient: false
       };
+      if (worklogEnabled) setWorklog(initialWorklogState());
       const eventSource = new EventSource(streamUrl);
       eventSourceRef.current = eventSource;
-      const evaluationStrategy2 = response.getEvaluationStrategy();
-      setEvaluationStrategy(evaluationStrategy2);
       eventSource.onopen = () => {
         streamState.openedAt = Date.now();
       };
@@ -564,23 +748,37 @@ function useAlquimia(config) {
       };
       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) {
@@ -591,13 +789,17 @@ function useAlquimia(config) {
       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);
+    if (worklogEnabled) {
+      setWorklog((prev) => reduceWorklog(prev ?? initialWorklogState(), frameToRecord(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");
@@ -605,7 +807,7 @@ function useAlquimia(config) {
           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;
@@ -619,10 +821,9 @@ function useAlquimia(config) {
       setHasThinkings(true);
       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);
     }
@@ -654,8 +855,8 @@ function useAlquimia(config) {
     setSessionId,
     setLastRequest,
     setIsAudioRecording,
-    evaluationStrategy,
     hasThinkings,
+    worklog,
     attachments,
     addAttachment,
     addAttachments,
@@ -666,7 +867,7 @@ function useAlquimia(config) {
 }
 
 // src/hooks/useRatings.ts
-var import_react2 = require("react");
+var import_react3 = require("react");
 var initialState = {
   ratingStars: 0,
   ratingThumbs: "",
@@ -685,9 +886,9 @@ function ratingReducer(state, action) {
   }
 }
 function useRatings({ assistantId, sendRating, topicId }) {
-  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
-  const [hasReviewed, setHasReviewed] = (0, import_react2.useState)(false);
-  const [state, dispatch] = (0, import_react2.useReducer)(ratingReducer, initialState);
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(false);
+  const [hasReviewed, setHasReviewed] = (0, import_react3.useState)(false);
+  const [state, dispatch] = (0, import_react3.useReducer)(ratingReducer, initialState);
   const setRatingStars = (rating) => {
     dispatch({ type: "SET_RATING_STARS", payload: rating });
   };