@reverbia/sdk 1.0.0-next.20260110221448 → 1.0.0-next.20260111110909

package/dist/react/index.mjs

@@ -875,14 +875,128 @@ function validateToken(token) {
   }
   return { valid: true };
 }
-function createStreamAccumulator() {
+function parseReasoningTags(content, previousPartialTag = "") {
+  const OPENING_TAG = "<think>";
+  const CLOSING_TAG = "</think>";
+  const OPENING_TAG_LEN = OPENING_TAG.length;
+  const CLOSING_TAG_LEN = CLOSING_TAG.length;
+  const fullContent = previousPartialTag + content;
+  let messageContent = "";
+  let reasoningContent = "";
+  let partialTag = "";
+  let i = 0;
+  let insideReasoning = false;
+  if (previousPartialTag) {
+    if (previousPartialTag === OPENING_TAG) {
+      insideReasoning = true;
+      i = OPENING_TAG_LEN;
+    } else if (OPENING_TAG.startsWith(previousPartialTag)) {
+      if (fullContent.startsWith(OPENING_TAG)) {
+        insideReasoning = true;
+        i = OPENING_TAG_LEN;
+      } else if (OPENING_TAG.startsWith(fullContent.slice(0, Math.min(OPENING_TAG_LEN, fullContent.length)))) {
+        return {
+          messageContent: "",
+          reasoningContent: "",
+          partialTag: fullContent.slice(0, Math.min(OPENING_TAG_LEN, fullContent.length))
+        };
+      } else {
+        messageContent = previousPartialTag;
+        i = previousPartialTag.length;
+      }
+    } else if (CLOSING_TAG.startsWith(previousPartialTag)) {
+      if (fullContent.startsWith(CLOSING_TAG)) {
+        i = CLOSING_TAG_LEN;
+        insideReasoning = false;
+      } else if (CLOSING_TAG.startsWith(fullContent.slice(0, Math.min(CLOSING_TAG_LEN, fullContent.length)))) {
+        return {
+          messageContent: "",
+          reasoningContent: "",
+          partialTag: fullContent.slice(0, Math.min(CLOSING_TAG_LEN, fullContent.length))
+        };
+      } else {
+        reasoningContent = previousPartialTag;
+        i = previousPartialTag.length;
+        insideReasoning = true;
+      }
+    } else {
+      if (insideReasoning) {
+        reasoningContent = previousPartialTag;
+      } else {
+        messageContent = previousPartialTag;
+      }
+      i = previousPartialTag.length;
+    }
+  }
+  while (i < fullContent.length) {
+    if (insideReasoning) {
+      const closeIndex = fullContent.indexOf(CLOSING_TAG, i);
+      if (closeIndex === -1) {
+        const remaining = fullContent.slice(i);
+        if (remaining.length < CLOSING_TAG_LEN) {
+          const potentialClose = remaining;
+          if (CLOSING_TAG.startsWith(potentialClose)) {
+            partialTag = potentialClose;
+          } else {
+            reasoningContent += remaining;
+          }
+        } else {
+          reasoningContent += remaining;
+        }
+        break;
+      }
+      const contentBeforeClose = fullContent.slice(i, closeIndex);
+      if (contentBeforeClose) {
+        reasoningContent += contentBeforeClose;
+      }
+      i = closeIndex + CLOSING_TAG_LEN;
+      insideReasoning = false;
+    } else {
+      const openIndex = fullContent.indexOf(OPENING_TAG, i);
+      if (openIndex === -1) {
+        const remaining = fullContent.slice(i);
+        if (remaining.length < OPENING_TAG_LEN) {
+          const potentialOpen = remaining;
+          if (OPENING_TAG.startsWith(potentialOpen)) {
+            partialTag = potentialOpen;
+          } else {
+            messageContent += remaining;
+          }
+        } else {
+          messageContent += remaining;
+        }
+        break;
+      }
+      messageContent += fullContent.slice(i, openIndex);
+      i = openIndex + OPENING_TAG_LEN;
+      insideReasoning = true;
+    }
+  }
+  if (messageContent.includes(OPENING_TAG) || messageContent.includes(CLOSING_TAG)) {
+    console.warn("[parseReasoningTags] Warning: Tag found in messageContent, removing");
+    messageContent = messageContent.replace(new RegExp(OPENING_TAG.replace(/[<>]/g, "\\$&"), "g"), "");
+    messageContent = messageContent.replace(new RegExp(CLOSING_TAG.replace(/[<>]/g, "\\$&"), "g"), "");
+  }
+  if (reasoningContent.includes(OPENING_TAG) || reasoningContent.includes(CLOSING_TAG)) {
+    console.warn("[parseReasoningTags] Warning: Tag found in reasoningContent, removing");
+    reasoningContent = reasoningContent.replace(new RegExp(OPENING_TAG.replace(/[<>]/g, "\\$&"), "g"), "");
+    reasoningContent = reasoningContent.replace(new RegExp(CLOSING_TAG.replace(/[<>]/g, "\\$&"), "g"), "");
+  }
+  return {
+    messageContent,
+    reasoningContent,
+    partialTag
+  };
+}
+function createStreamAccumulator(initialModel) {
   return {
     content: "",
     thinking: "",
     responseId: "",
-    responseModel: "",
+    responseModel: initialModel || "",
     usage: {},
-    toolCalls: /* @__PURE__ */ new Map()
+    toolCalls: /* @__PURE__ */ new Map(),
+    partialReasoningTag: ""
   };
 }
 function createErrorResult(message, onError) {
@@ -1052,7 +1166,7 @@ var ResponsesStrategy = class {
       const delta = typedChunk.delta;
       if (delta) {
         const deltaText = typeof delta === "string" ? delta : delta.OfString;
-        if (deltaText) {
+        if (deltaText && deltaText.trim().length > 0) {
           accumulator.content += deltaText;
           result.content = deltaText;
         }
@@ -1179,8 +1293,21 @@ var CompletionsStrategy = class {
       const choice = typedChunk.choices[0];
       if (choice.delta) {
         if (choice.delta.content) {
-          accumulator.content += choice.delta.content;
-          result.content = choice.delta.content;
+          const parseResult = parseReasoningTags(
+            choice.delta.content,
+            accumulator.partialReasoningTag || ""
+          );
+          accumulator.content += parseResult.messageContent;
+          accumulator.thinking += parseResult.reasoningContent;
+          accumulator.partialReasoningTag = parseResult.partialTag;
+          const willEmitMessage = parseResult.messageContent && parseResult.messageContent.trim().length > 0;
+          const willEmitReasoning = parseResult.reasoningContent && parseResult.reasoningContent.trim().length > 0;
+          if (willEmitMessage) {
+            result.content = parseResult.messageContent;
+          }
+          if (willEmitReasoning) {
+            result.thinking = parseResult.reasoningContent;
+          }
         }
         if (choice.delta.tool_calls) {
           for (const toolCallDelta of choice.delta.tool_calls) {
@@ -1209,8 +1336,19 @@ var CompletionsStrategy = class {
       }
       if (choice.message) {
         if (choice.message.content) {
-          accumulator.content = choice.message.content;
-          result.content = choice.message.content;
+          const parseResult = parseReasoningTags(
+            choice.message.content,
+            accumulator.partialReasoningTag || ""
+          );
+          accumulator.content = parseResult.messageContent;
+          accumulator.thinking += parseResult.reasoningContent;
+          accumulator.partialReasoningTag = parseResult.partialTag;
+          if (parseResult.messageContent && parseResult.messageContent.trim().length > 0) {
+            result.content = parseResult.messageContent;
+          }
+          if (parseResult.reasoningContent && parseResult.reasoningContent.trim().length > 0) {
+            result.thinking = parseResult.reasoningContent;
+          }
         }
         if (choice.message.tool_calls) {
           for (let i = 0; i < choice.message.tool_calls.length; i++) {
@@ -1238,6 +1376,23 @@ var CompletionsStrategy = class {
   }
   buildFinalResponse(accumulator) {
     const output = [];
+    let finalContent = accumulator.content;
+    let finalThinking = accumulator.thinking;
+    if (accumulator.partialReasoningTag) {
+      const finalParse = parseReasoningTags("", accumulator.partialReasoningTag);
+      finalContent += finalParse.messageContent;
+      if (finalParse.reasoningContent) {
+        finalThinking += finalParse.reasoningContent;
+      }
+    }
+    if (finalThinking) {
+      output.push({
+        type: "reasoning",
+        role: "assistant",
+        content: [{ type: "output_text", text: finalThinking }],
+        status: "completed"
+      });
+    }
     if (accumulator.toolCalls.size > 0) {
       for (const toolCall of accumulator.toolCalls.values()) {
         output.push({
@@ -1252,7 +1407,7 @@ var CompletionsStrategy = class {
     output.push({
       type: "message",
       role: "assistant",
-      content: [{ type: "output_text", text: accumulator.content }],
+      content: [{ type: "output_text", text: finalContent }],
       status: "completed"
     });
     return {
@@ -1432,7 +1587,7 @@ function useChat(options) {
             sseError = error instanceof Error ? error : new Error(String(error));
           }
         });
-        const accumulator = createStreamAccumulator();
+        const accumulator = createStreamAccumulator(model || void 0);
         try {
           for await (const chunk of sseResult.stream) {
             if (isDoneMarker(chunk)) {
@@ -1627,7 +1782,7 @@ Executing tool: ${toolInfo}
                 sseError = error instanceof Error ? error : new Error(String(error));
               }
             });
-            const continuationAccumulator = createStreamAccumulator();
+            const continuationAccumulator = createStreamAccumulator(model || void 0);
             try {
               for await (const chunk of continuationResult.stream) {
                 if (isDoneMarker(chunk)) {
@@ -2877,44 +3032,80 @@ var BlobUrlManager = class {
 // src/react/useChatStorage.ts
 function replaceUrlWithMCPPlaceholder(content, url, fileId) {
   const escapedUrl = url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const placeholder = `![MCP_IMAGE:${fileId}]`;
+  const placeholder = createFilePlaceholder(fileId);
   let result = content;
+  console.log(
+    `[replaceUrlWithMCPPlaceholder] Replacing URL with placeholder:`,
+    url,
+    "->",
+    placeholder
+  );
+  const htmlImgPatternDouble = new RegExp(
+    `<img[^>]*src="${escapedUrl}"[^>]*>`,
+    "gi"
+  );
+  const doubleMatches = result.match(htmlImgPatternDouble);
+  if (doubleMatches) {
+    console.log(
+      `[replaceUrlWithMCPPlaceholder] Replacing ${doubleMatches.length} HTML img tag(s) with double quotes:`,
+      doubleMatches,
+      "->",
+      placeholder
+    );
+  }
+  result = result.replace(htmlImgPatternDouble, placeholder);
+  const htmlImgPatternSingle = new RegExp(
+    `<img[^>]*src='${escapedUrl}'[^>]*>`,
+    "gi"
+  );
+  const singleMatches = result.match(htmlImgPatternSingle);
+  if (singleMatches) {
+    console.log(
+      `[replaceUrlWithMCPPlaceholder] Replacing ${singleMatches.length} HTML img tag(s) with single quotes:`,
+      singleMatches,
+      "->",
+      placeholder
+    );
+  }
+  result = result.replace(htmlImgPatternSingle, placeholder);
   const markdownImagePattern = new RegExp(
     `!\\[[^\\]]*\\]\\([\\s]*${escapedUrl}[\\s]*\\)`,
     "g"
   );
+  const markdownMatches = result.match(markdownImagePattern);
+  if (markdownMatches) {
+    console.log(
+      `[replaceUrlWithMCPPlaceholder] Replacing ${markdownMatches.length} markdown image(s):`,
+      markdownMatches,
+      "->",
+      placeholder
+    );
+  }
   result = result.replace(markdownImagePattern, placeholder);
-  result = result.replace(new RegExp(escapedUrl, "g"), placeholder);
-  const orphanedMarkdownPattern = new RegExp(
-    `!\\[[^\\]]*\\]\\([\\s]*\\!\\[MCP_IMAGE:${fileId}\\][\\s]*\\)`,
-    "g"
+  const rawUrlPattern = new RegExp(escapedUrl, "g");
+  const rawMatches = result.match(rawUrlPattern);
+  if (rawMatches) {
+    console.log(
+      `[replaceUrlWithMCPPlaceholder] Replacing ${rawMatches.length} raw URL(s):`,
+      rawMatches,
+      "->",
+      placeholder
+    );
+  }
+  result = result.replace(rawUrlPattern, placeholder);
+  console.log(
+    `[replaceUrlWithMCPPlaceholder] Final result length: ${result.length}, original length: ${content.length}`
   );
-  result = result.replace(orphanedMarkdownPattern, placeholder);
   return result;
 }
 function findFileIdBySourceUrl(files, sourceUrl) {
   return files?.find((f) => f.sourceUrl === sourceUrl)?.id;
 }
-async function isUrlValid(url, timeoutMs = 5e3) {
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-    const response = await fetch(url, {
-      method: "GET",
-      headers: { Range: "bytes=0-0" },
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    return response.ok || response.status === 206;
-  } catch {
-    return false;
-  }
-}
-async function storedToLlmapiMessage(stored) {
+function storedToLlmapiMessage(stored) {
   let textContent = stored.content;
   const fileUrlMap = /* @__PURE__ */ new Map();
   const imageParts = [];
-  if (stored.files?.length) {
+  if (stored.role !== "assistant" && stored.files?.length) {
     for (const file of stored.files) {
       if (file.url) {
         imageParts.push({
@@ -2922,14 +3113,17 @@ async function storedToLlmapiMessage(stored) {
           image_url: { url: file.url }
         });
       } else if (file.sourceUrl) {
-        const isValid = await isUrlValid(file.sourceUrl);
-        if (isValid) {
-          imageParts.push({
-            type: "image_url",
-            image_url: { url: file.sourceUrl }
-          });
-          fileUrlMap.set(file.id, file.sourceUrl);
-        }
+        imageParts.push({
+          type: "image_url",
+          image_url: { url: file.sourceUrl }
+        });
+        fileUrlMap.set(file.id, file.sourceUrl);
+      }
+    }
+  } else if (stored.role === "assistant" && stored.files?.length) {
+    for (const file of stored.files) {
+      if (file.sourceUrl) {
+        fileUrlMap.set(file.id, file.sourceUrl);
       }
     }
   }
@@ -3063,26 +3257,63 @@ function useChatStorage(options) {
               if (fileIds.length === 0) {
                 return msg;
               }
+              console.log(
+                `[getMessages] Found ${fileIds.length} placeholder(s) in message ${msg.uniqueId}:`,
+                fileIds
+              );
               let resolvedContent = msg.content;
               for (const fileId of fileIds) {
+                const placeholder = createFilePlaceholder(fileId);
+                console.log(
+                  `[getMessages] Resolving placeholder: ${placeholder} (fileId: ${fileId})`
+                );
                 let url = blobManager.getUrl(fileId);
                 if (!url) {
+                  console.log(
+                    `[getMessages] No cached URL for ${fileId}, reading from OPFS...`
+                  );
                   const result = await readEncryptedFile(fileId, encryptionKey);
                   if (result) {
                     url = blobManager.createUrl(fileId, result.blob);
+                    console.log(
+                      `[getMessages] Created blob URL for ${fileId}:`,
+                      url
+                    );
+                  } else {
+                    console.warn(
+                      `[getMessages] Failed to read file ${fileId} from OPFS`
+                    );
                   }
+                } else {
+                  console.log(
+                    `[getMessages] Using cached blob URL for ${fileId}:`,
+                    url
+                  );
                 }
                 if (url) {
-                  const placeholder = createFilePlaceholder(fileId);
+                  const placeholderRegex = new RegExp(
+                    placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+                    "g"
+                  );
+                  const matches = resolvedContent.match(placeholderRegex);
+                  const replacement = `![image](${url})`;
+                  console.log(
+                    `[getMessages] Replacing ${matches?.length || 0} instance(s) of ${placeholder} with:`,
+                    replacement
+                  );
                   resolvedContent = resolvedContent.replace(
-                    new RegExp(
-                      placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
-                      "g"
-                    ),
-                    `![image](${url})`
+                    placeholderRegex,
+                    replacement
+                  );
+                } else {
+                  console.warn(
+                    `[getMessages] No URL available for ${fileId}, placeholder ${placeholder} will remain in content`
                   );
                 }
               }
+              console.log(
+                `[getMessages] Resolved content length: ${resolvedContent.length}, original length: ${msg.content.length}`
+              );
               return { ...msg, content: resolvedContent };
             })
           );
@@ -3222,16 +3453,42 @@ function useChatStorage(options) {
       const { replaceUrls = true } = options2 ?? {};
       try {
         const MCP_IMAGE_URL_PATTERN = new RegExp(
-          `https://${MCP_R2_DOMAIN.replace(/\./g, "\\.")}[^\\s)]*`,
+          `https://${MCP_R2_DOMAIN.replace(/\./g, "\\.")}[^\\s"'<>)]*`,
           "g"
         );
         const urlMatches = content.match(MCP_IMAGE_URL_PATTERN);
         if (!urlMatches || urlMatches.length === 0) {
           return { processedFiles: [], cleanedContent: content };
         }
-        const uniqueUrls = [...new Set(urlMatches)];
+        const cleanedUrls = urlMatches.map((url) => url.replace(/["']+$/, ""));
+        const uniqueUrls = [...new Set(cleanedUrls)];
         const processedFiles = [];
         let cleanedContent = content;
+        const urlOccurrenceCounts = /* @__PURE__ */ new Map();
+        uniqueUrls.forEach((url) => {
+          const escapedUrl = url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const htmlDoublePattern = new RegExp(
+            `<img[^>]*src="${escapedUrl}"[^>]*>`,
+            "gi"
+          );
+          const htmlSinglePattern = new RegExp(
+            `<img[^>]*src='${escapedUrl}'[^>]*>`,
+            "gi"
+          );
+          const markdownPattern = new RegExp(
+            `!\\[[^\\]]*\\]\\([\\s]*${escapedUrl}[\\s]*\\)`,
+            "g"
+          );
+          const rawPattern = new RegExp(escapedUrl, "g");
+          const htmlDoubleMatches = content.match(htmlDoublePattern)?.length || 0;
+          const htmlSingleMatches = content.match(htmlSinglePattern)?.length || 0;
+          const markdownMatches = content.match(markdownPattern)?.length || 0;
+          const rawMatches = (content.match(rawPattern)?.length || 0) - htmlDoubleMatches - htmlSingleMatches - markdownMatches;
+          urlOccurrenceCounts.set(
+            url,
+            htmlDoubleMatches + htmlSingleMatches + markdownMatches + rawMatches
+          );
+        });
         const results = await Promise.allSettled(
           uniqueUrls.map(async (imageUrl) => {
             const controller = new AbortController();
@@ -3263,27 +3520,85 @@ function useChatStorage(options) {
         );
         const replaceUrlWithPlaceholder = (imageUrl, fileId) => {
           const escapedUrl = imageUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-          const placeholder = `![MCP_IMAGE:${fileId}]`;
-          const markdownImagePattern = new RegExp(
-            `!\\[[^\\]]*\\]\\([\\s]*${escapedUrl}[\\s]*\\)`,
-            "g"
-          );
-          cleanedContent = cleanedContent.replace(
-            markdownImagePattern,
+          const placeholder = createFilePlaceholder(fileId);
+          let replacementCount = 0;
+          console.log(
+            `[extractAndStoreMCPImages] Replacing URL with placeholder:`,
+            imageUrl,
+            "->",
             placeholder
           );
-          cleanedContent = cleanedContent.replace(
-            new RegExp(escapedUrl, "g"),
-            placeholder
+          const htmlImgPatternDouble = new RegExp(
+            `<img[^>]*src="${escapedUrl}"[^>]*>`,
+            "gi"
           );
-          const orphanedMarkdownPattern = new RegExp(
-            `!\\[[^\\]]*\\]\\([\\s]*\\!\\[MCP_IMAGE:${fileId}\\][\\s]*\\)`,
+          const doubleMatches = cleanedContent.match(htmlImgPatternDouble);
+          if (doubleMatches) {
+            console.log(
+              `[extractAndStoreMCPImages] Replacing ${doubleMatches.length} HTML img tag(s) with double quotes:`,
+              doubleMatches,
+              "->",
+              placeholder
+            );
+            replacementCount += doubleMatches.length;
+            cleanedContent = cleanedContent.replace(
+              htmlImgPatternDouble,
+              placeholder
+            );
+          }
+          const htmlImgPatternSingle = new RegExp(
+            `<img[^>]*src='${escapedUrl}'[^>]*>`,
+            "gi"
+          );
+          const singleMatches = cleanedContent.match(htmlImgPatternSingle);
+          if (singleMatches) {
+            console.log(
+              `[extractAndStoreMCPImages] Replacing ${singleMatches.length} HTML img tag(s) with single quotes:`,
+              singleMatches,
+              "->",
+              placeholder
+            );
+            replacementCount += singleMatches.length;
+            cleanedContent = cleanedContent.replace(
+              htmlImgPatternSingle,
+              placeholder
+            );
+          }
+          const markdownImagePattern = new RegExp(
+            `!\\[[^\\]]*\\]\\([\\s]*${escapedUrl}[\\s]*\\)`,
             "g"
           );
-          cleanedContent = cleanedContent.replace(
-            orphanedMarkdownPattern,
-            placeholder
+          const markdownMatches = cleanedContent.match(markdownImagePattern);
+          if (markdownMatches) {
+            console.log(
+              `[extractAndStoreMCPImages] Replacing ${markdownMatches.length} markdown image(s):`,
+              markdownMatches,
+              "->",
+              placeholder
+            );
+            replacementCount += markdownMatches.length;
+            cleanedContent = cleanedContent.replace(
+              markdownImagePattern,
+              placeholder
+            );
+          }
+          const rawUrlPattern = new RegExp(escapedUrl, "g");
+          const rawMatches = cleanedContent.match(rawUrlPattern);
+          if (rawMatches) {
+            console.log(
+              `[extractAndStoreMCPImages] Replacing ${rawMatches.length} raw URL(s):`,
+              rawMatches,
+              "->",
+              placeholder
+            );
+            replacementCount += rawMatches.length;
+            cleanedContent = cleanedContent.replace(rawUrlPattern, placeholder);
+          }
+          console.log(
+            `[extractAndStoreMCPImages] Total replacements made: ${replacementCount} for URL:`,
+            imageUrl
           );
+          return replacementCount;
         };
         results.forEach((result, i) => {
           const imageUrl = uniqueUrls[i];
@@ -3297,7 +3612,29 @@ function useChatStorage(options) {
               sourceUrl: imageUrl
             });
             if (replaceUrls && imageUrl) {
-              replaceUrlWithPlaceholder(imageUrl, fileId);
+              const replacementCount = replaceUrlWithPlaceholder(
+                imageUrl,
+                fileId
+              );
+              const expectedCount = urlOccurrenceCounts.get(imageUrl) || 0;
+              if (replacementCount < expectedCount) {
+                console.warn(
+                  `[extractAndStoreMCPImages] Not all instances of URL replaced. Expected ${expectedCount}, replaced ${replacementCount}:`,
+                  imageUrl
+                );
+              }
+              const escapedUrl = imageUrl.replace(
+                /[.*+?^${}()|[\]\\]/g,
+                "\\$&"
+              );
+              const remainingPattern = new RegExp(escapedUrl, "g");
+              const remainingMatches = cleanedContent.match(remainingPattern);
+              if (remainingMatches && remainingMatches.length > 0) {
+                console.warn(
+                  `[extractAndStoreMCPImages] Found ${remainingMatches.length} remaining instance(s) of URL after replacement:`,
+                  imageUrl
+                );
+              }
             }
           } else {
             console.error(
@@ -3330,17 +3667,43 @@ function useChatStorage(options) {
           return { processedFiles: [], cleanedContent: content };
         }
         const MCP_IMAGE_URL_PATTERN = new RegExp(
-          `https://${MCP_R2_DOMAIN.replace(/\./g, "\\.")}[^\\s)]*`,
+          `https://${MCP_R2_DOMAIN.replace(/\./g, "\\.")}[^\\s"'<>)]*`,
           "g"
         );
         const urlMatches = content.match(MCP_IMAGE_URL_PATTERN);
         if (!urlMatches || urlMatches.length === 0) {
           return { processedFiles: [], cleanedContent: content };
         }
-        const uniqueUrls = [...new Set(urlMatches)];
+        const cleanedUrls = urlMatches.map((url) => url.replace(/["']+$/, ""));
+        const uniqueUrls = [...new Set(cleanedUrls)];
         const encryptionKey = await getEncryptionKey(address);
         const processedFiles = [];
         let cleanedContent = content;
+        const urlOccurrenceCounts = /* @__PURE__ */ new Map();
+        uniqueUrls.forEach((url) => {
+          const escapedUrl = url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const htmlDoublePattern = new RegExp(
+            `<img[^>]*src="${escapedUrl}"[^>]*>`,
+            "gi"
+          );
+          const htmlSinglePattern = new RegExp(
+            `<img[^>]*src='${escapedUrl}'[^>]*>`,
+            "gi"
+          );
+          const markdownPattern = new RegExp(
+            `!\\[[^\\]]*\\]\\([\\s]*${escapedUrl}[\\s]*\\)`,
+            "g"
+          );
+          const rawPattern = new RegExp(escapedUrl, "g");
+          const htmlDoubleMatches = content.match(htmlDoublePattern)?.length || 0;
+          const htmlSingleMatches = content.match(htmlSinglePattern)?.length || 0;
+          const markdownMatches = content.match(markdownPattern)?.length || 0;
+          const rawMatches = (content.match(rawPattern)?.length || 0) - htmlDoubleMatches - htmlSingleMatches - markdownMatches;
+          urlOccurrenceCounts.set(
+            url,
+            htmlDoubleMatches + htmlSingleMatches + markdownMatches + rawMatches
+          );
+        });
         const results = await Promise.allSettled(
           uniqueUrls.map(async (imageUrl) => {
             const controller = new AbortController();
@@ -3382,12 +3745,98 @@ function useChatStorage(options) {
             });
             const placeholder = createFilePlaceholder(fileId);
             const escapedUrl = imageUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            let replacementCount = 0;
+            console.log(
+              `[extractAndStoreEncryptedMCPImages] Replacing URL with placeholder:`,
+              imageUrl,
+              "->",
+              placeholder
+            );
+            const htmlImgPatternDouble = new RegExp(
+              `<img[^>]*src="${escapedUrl}"[^>]*>`,
+              "gi"
+            );
+            const doubleMatches = cleanedContent.match(htmlImgPatternDouble);
+            if (doubleMatches) {
+              console.log(
+                `[extractAndStoreEncryptedMCPImages] Replacing ${doubleMatches.length} HTML img tag(s) with double quotes:`,
+                doubleMatches,
+                "->",
+                placeholder
+              );
+              replacementCount += doubleMatches.length;
+              cleanedContent = cleanedContent.replace(
+                htmlImgPatternDouble,
+                placeholder
+              );
+            }
+            const htmlImgPatternSingle = new RegExp(
+              `<img[^>]*src='${escapedUrl}'[^>]*>`,
+              "gi"
+            );
+            const singleMatches = cleanedContent.match(htmlImgPatternSingle);
+            if (singleMatches) {
+              console.log(
+                `[extractAndStoreEncryptedMCPImages] Replacing ${singleMatches.length} HTML img tag(s) with single quotes:`,
+                singleMatches,
+                "->",
+                placeholder
+              );
+              replacementCount += singleMatches.length;
+              cleanedContent = cleanedContent.replace(
+                htmlImgPatternSingle,
+                placeholder
+              );
+            }
             const markdownImagePattern = new RegExp(
               `!\\[[^\\]]*\\]\\([\\s]*${escapedUrl}[\\s]*\\)`,
               "g"
             );
-            cleanedContent = cleanedContent.replace(markdownImagePattern, placeholder);
-            cleanedContent = cleanedContent.replace(new RegExp(escapedUrl, "g"), placeholder);
+            const markdownMatches = cleanedContent.match(markdownImagePattern);
+            if (markdownMatches) {
+              console.log(
+                `[extractAndStoreEncryptedMCPImages] Replacing ${markdownMatches.length} markdown image(s):`,
+                markdownMatches,
+                "->",
+                placeholder
+              );
+              replacementCount += markdownMatches.length;
+              cleanedContent = cleanedContent.replace(
+                markdownImagePattern,
+                placeholder
+              );
+            }
+            const rawUrlPattern = new RegExp(escapedUrl, "g");
+            const rawMatches = cleanedContent.match(rawUrlPattern);
+            if (rawMatches) {
+              console.log(
+                `[extractAndStoreEncryptedMCPImages] Replacing ${rawMatches.length} raw URL(s):`,
+                rawMatches,
+                "->",
+                placeholder
+              );
+              replacementCount += rawMatches.length;
+              cleanedContent = cleanedContent.replace(rawUrlPattern, placeholder);
+            }
+            console.log(
+              `[extractAndStoreEncryptedMCPImages] Total replacements made: ${replacementCount} for URL:`,
+              imageUrl
+            );
+            const expectedCount = urlOccurrenceCounts.get(imageUrl) || 0;
+            if (replacementCount < expectedCount) {
+              console.warn(
+                `[extractAndStoreEncryptedMCPImages] Not all instances of URL replaced. Expected ${expectedCount}, replaced ${replacementCount}:`,
+                imageUrl
+              );
+            }
+            const remainingPattern = new RegExp(escapedUrl, "g");
+            const remainingMatches = cleanedContent.match(remainingPattern);
+            if (remainingMatches && remainingMatches.length > 0) {
+              console.warn(
+                `[extractAndStoreEncryptedMCPImages] Found ${remainingMatches.length} remaining instance(s) of URL after replacement:`,
+                imageUrl
+              );
+            }
           } else {
             console.error("[extractAndStoreEncryptedMCPImages] Failed:", result.reason);
           }
@@ -3452,9 +3901,7 @@ function useChatStorage(options) {
         const storedMessages = await getMessagesOp(storageCtx, convId);
         const validMessages = storedMessages.filter((msg) => !msg.error);
         const limitedMessages = validMessages.slice(-maxHistoryMessages);
-        const historyMessages = await Promise.all(
-          limitedMessages.map(storedToLlmapiMessage)
-        );
+        const historyMessages = limitedMessages.map(storedToLlmapiMessage);
         messagesToSend = [...historyMessages, ...messages];
       } else {
         messagesToSend = [...messages];