@paymanai/payman-typescript-ask-sdk 1.2.8 → 1.2.9

package/dist/index.mjs

@@ -529,7 +529,8 @@ function createFinalMessage(streamingId, state) {
     currentExecutingStepId: void 0,
     userActionResult: state.userActionResult,
     activeThinkingText: void 0,
-    allThinkingText: state.hasError ? void 0 : state.allThinkingText
+    allThinkingText: state.hasError ? void 0 : state.allThinkingText,
+    isResolvingImages: state.hasError ? void 0 : state.isResolvingImages
   };
 }
 function createCancelledMessageUpdate(steps, currentMessage) {
@@ -583,6 +584,16 @@ function buildUserActionUrl(config, userActionId, action) {
   const encodedUserActionId = encodeURIComponent(userActionId);
   return `${config.api.baseUrl}${basePath}/user-action/${encodedUserActionId}/${action}`;
 }
+function buildResolveImagesUrl(config) {
+  if (config.api.resolveImagesEndpoint) {
+    return `${config.api.baseUrl}${config.api.resolveImagesEndpoint}`;
+  }
+  const streamEndpoint = config.api.streamEndpoint || "/api/workflows/ask/stream";
+  const [endpointPath] = streamEndpoint.split("?");
+  const normalizedEndpointPath = endpointPath.replace(/\/+$/, "");
+  const basePath = normalizedEndpointPath.endsWith("/stream") ? normalizedEndpointPath.slice(0, -"/stream".length) : normalizedEndpointPath;
+  return `${config.api.baseUrl}${basePath}/resolve-image-urls`;
+}
 function buildRequestHeaders(config) {
   const headers = {
     ...config.api.headers
@@ -697,6 +708,58 @@ var activeStreamStore = {
     streams.delete(key);
   }
 };
+
+// src/utils/ragImageResolver.ts
+var RAG_IMAGE_REGEX = /\/api\/rag\/chunks\/[^"'\s]+\/image/;
+function hasRagImages(content) {
+  return RAG_IMAGE_REGEX.test(content);
+}
+async function waitForNextPaint(signal) {
+  if (signal?.aborted) return;
+  await new Promise((resolve) => {
+    let isSettled = false;
+    const finish = () => {
+      if (isSettled) return;
+      isSettled = true;
+      signal?.removeEventListener("abort", finish);
+      resolve();
+    };
+    signal?.addEventListener("abort", finish, { once: true });
+    if (typeof requestAnimationFrame === "function") {
+      requestAnimationFrame(() => {
+        setTimeout(finish, 0);
+      });
+      return;
+    }
+    setTimeout(finish, 0);
+  });
+}
+async function resolveRagImageUrls(config, content, signal) {
+  const url = buildResolveImagesUrl(config);
+  const baseHeaders = buildRequestHeaders(config);
+  const headers = { "Content-Type": "application/json", ...baseHeaders };
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ input: content }),
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  const text = await response.text();
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed === "string") return parsed;
+    if (typeof parsed.output === "string") return parsed.output;
+    if (typeof parsed.result === "string") return parsed.result;
+  } catch {
+  }
+  return text;
+}
+
+// src/hooks/useStreamManager.ts
 function useStreamManager(config, callbacks, setMessages, setIsWaitingForResponse) {
   const abortControllerRef = useRef(null);
   const configRef = useRef(config);
@@ -862,9 +925,11 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
             if (state.currentSessionId && state.currentSessionId !== sessionId) {
               callbacksRef.current.onSessionIdChange?.(state.currentSessionId);
             }
+            const needsImageResolve = !state.hasError && !abortController.signal.aborted && hasRagImages(state.accumulatedContent);
             const finalMessage = createFinalMessage(streamingId, {
               ...state,
-              sessionId: state.currentSessionId || sessionId
+              sessionId: state.currentSessionId || sessionId,
+              isResolvingImages: needsImageResolve
             });
             setMessages(
               (prev) => prev.map(
@@ -875,6 +940,30 @@ function useStreamManager(config, callbacks, setMessages, setIsWaitingForRespons
           }
         });
         clearThrottle();
+        const shouldResolveImages = !abortController.signal.aborted && !state.hasError && hasRagImages(state.accumulatedContent);
+        if (shouldResolveImages) {
+          await waitForNextPaint(abortController.signal);
+        }
+        if (shouldResolveImages && !abortController.signal.aborted) {
+          try {
+            const resolvedContent = await resolveRagImageUrls(
+              currentConfig,
+              state.accumulatedContent,
+              abortController.signal
+            );
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? { ...msg, content: resolvedContent, isResolvingImages: false } : msg
+              )
+            );
+          } catch {
+            setMessages(
+              (prev) => prev.map(
+                (msg) => msg.id === streamingId ? { ...msg, isResolvingImages: false } : msg
+              )
+            );
+          }
+        }
         return state.currentSessionId;
       } catch (error) {
         clearThrottle();