@workglow/ai-provider 0.0.109 → 0.0.111

package/dist/{index-y0yn7yrm.js → index-qv377n6c.js}

@@ -64,61 +64,47 @@ var getPipeline = async (model, onProgress, options = {}, signal, progressScaleM
   return loadPromise;
 };
 var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKey, signal) => {
-  const fileSizes = new Map;
-  const fileProgress = new Map;
-  const fileCompleted = new Set;
-  const fileFirstSent = new Set;
-  const fileLastSent = new Set;
-  const fileLastEventTime = new Map;
-  const pendingProgressByFile = new Map;
+  let lastProgressTime = 0;
+  let pendingProgress = null;
   let throttleTimer = null;
   const THROTTLE_MS = 160;
-  const estimatedTinyFiles = 3;
-  const estimatedMediumFiles = 1;
-  const estimatedTinySize = 1024;
-  const estimatedMediumSize = 20971520;
-  const estimatedLargeSize = 1073741824;
-  const baseEstimate = estimatedTinyFiles * estimatedTinySize + estimatedMediumFiles * estimatedMediumSize;
-  const sendProgress = (overallProgress, file, fileProgressValue, isFirst, isLast) => {
+  const sendProgress = (progress, file, fileProgress) => {
     const now = Date.now();
-    const lastTime = fileLastEventTime.get(file) || 0;
-    const timeSinceLastEvent = now - lastTime;
-    const shouldThrottle = !isFirst && !isLast && timeSinceLastEvent < THROTTLE_MS;
-    if (shouldThrottle) {
-      pendingProgressByFile.set(file, {
-        progress: overallProgress,
-        file,
-        fileProgress: fileProgressValue
-      });
+    const timeSinceLastEvent = now - lastProgressTime;
+    const isFirst = lastProgressTime === 0;
+    const isFinal = progress >= progressScaleMax;
+    if (isFirst || isFinal) {
+      if (throttleTimer) {
+        clearTimeout(throttleTimer);
+        throttleTimer = null;
+      }
+      pendingProgress = null;
+      onProgress(Math.round(progress), "Downloading model", { file, progress: fileProgress });
+      lastProgressTime = now;
+      return;
+    }
+    if (timeSinceLastEvent < THROTTLE_MS) {
+      pendingProgress = { progress, file, fileProgress };
       if (!throttleTimer) {
         const timeRemaining = Math.max(1, THROTTLE_MS - timeSinceLastEvent);
         throttleTimer = setTimeout(() => {
-          for (const [pendingFile, pending] of pendingProgressByFile.entries()) {
-            onProgress(Math.round(pending.progress), "Downloading model", {
-              file: pendingFile,
-              progress: pending.fileProgress
+          throttleTimer = null;
+          if (pendingProgress) {
+            onProgress(Math.round(pendingProgress.progress), "Downloading model", {
+              file: pendingProgress.file,
+              progress: pendingProgress.fileProgress
             });
-            fileLastEventTime.set(pendingFile, Date.now());
+            lastProgressTime = Date.now();
+            pendingProgress = null;
           }
-          pendingProgressByFile.clear();
-          throttleTimer = null;
         }, timeRemaining);
       }
       return;
     }
-    onProgress(Math.round(overallProgress), "Downloading model", {
-      file,
-      progress: fileProgressValue
-    });
-    fileLastEventTime.set(file, now);
-    pendingProgressByFile.delete(file);
-    if (throttleTimer && pendingProgressByFile.size === 0) {
-      clearTimeout(throttleTimer);
-      throttleTimer = null;
-    }
+    onProgress(Math.round(progress), "Downloading model", { file, progress: fileProgress });
+    lastProgressTime = now;
+    pendingProgress = null;
   };
-  let hasSeenSubstantialFile = false;
-  const substantialFileThreshold = 1048576;
   const abortSignal = signal;
   const modelPath = model.provider_config.model_path;
   const modelController = new AbortController;
@@ -131,116 +117,31 @@ var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKe
     }
   }
   const progressCallback = (status) => {
-    if (abortSignal?.aborted) {
+    if (abortSignal?.aborted)
       return;
-    }
-    if (status.status === "progress") {
-      const file = status.file;
-      const fileTotal = status.total;
-      const fileProgressValue = status.progress;
-      if (!fileSizes.has(file)) {
-        fileSizes.set(file, fileTotal);
-        fileProgress.set(file, 0);
-        if (fileTotal >= substantialFileThreshold) {
-          hasSeenSubstantialFile = true;
-        }
-      }
-      fileProgress.set(file, fileProgressValue);
-      const isComplete = fileProgressValue >= 100;
-      if (isComplete && !fileCompleted.has(file)) {
-        fileCompleted.add(file);
-        fileProgress.set(file, 100);
-      }
-      let actualLoadedSize = 0;
-      let actualTotalSize = 0;
-      const tinyThreshold = 102400;
-      const mediumThreshold = 104857600;
-      let seenTinyCount = 0;
-      let seenMediumCount = 0;
-      let seenLargeCount = 0;
-      for (const [trackedFile, size] of fileSizes.entries()) {
-        actualTotalSize += size;
-        const progress = fileProgress.get(trackedFile) || 0;
-        actualLoadedSize += size * progress / 100;
-        if (size < tinyThreshold) {
-          seenTinyCount++;
-        } else if (size < mediumThreshold) {
-          seenMediumCount++;
-        } else {
-          seenLargeCount++;
-        }
-      }
-      const unseenTinyFiles = Math.max(0, estimatedTinyFiles - seenTinyCount);
-      const unseenMediumFiles = Math.max(0, estimatedMediumFiles - seenMediumCount);
-      let estimatedLargeFiles;
-      if (seenLargeCount > 0) {
-        estimatedLargeFiles = 2;
-      } else {
-        estimatedLargeFiles = 1;
-      }
-      const unseenLargeFiles = Math.max(0, estimatedLargeFiles - seenLargeCount);
-      const adjustedTotalSize = actualTotalSize + unseenTinyFiles * estimatedTinySize + unseenMediumFiles * estimatedMediumSize + unseenLargeFiles * estimatedLargeSize;
-      const rawProgress = adjustedTotalSize > 0 ? actualLoadedSize / adjustedTotalSize * 100 : 0;
-      const overallProgress = rawProgress * progressScaleMax / 100;
-      const isFirst = !fileFirstSent.has(file);
-      const isLast = isComplete && !fileLastSent.has(file);
-      if (isFirst) {
-        fileFirstSent.add(file);
-      }
-      if (isLast) {
-        fileLastSent.add(file);
-      }
-      if (hasSeenSubstantialFile) {
-        sendProgress(overallProgress, file, fileProgressValue, isFirst, isLast);
-      }
-    } else if (status.status === "done" || status.status === "download") {
-      const file = status.file;
-      const fileSize = fileSizes.get(file) || 0;
-      if (fileSize >= substantialFileThreshold) {
-        hasSeenSubstantialFile = true;
-      }
-      if (!fileCompleted.has(file)) {
-        fileCompleted.add(file);
-        fileProgress.set(file, 100);
-        let actualLoadedSize = 0;
-        let actualTotalSize = 0;
-        const tinyThreshold = 102400;
-        const mediumThreshold = 104857600;
-        let seenTinyCount = 0;
-        let seenMediumCount = 0;
-        let seenLargeCount = 0;
-        for (const [trackedFile, size] of fileSizes.entries()) {
-          actualTotalSize += size;
-          const progress = fileProgress.get(trackedFile) || 0;
-          actualLoadedSize += size * progress / 100;
-          if (size < tinyThreshold) {
-            seenTinyCount++;
-          } else if (size < mediumThreshold) {
-            seenMediumCount++;
-          } else {
-            seenLargeCount++;
+    if (status.status === "progress_total") {
+      const totalStatus = status;
+      const scaledProgress = totalStatus.progress * progressScaleMax / 100;
+      let activeFile = "";
+      let activeFileProgress = 0;
+      const files = totalStatus.files;
+      if (files) {
+        for (const [file, info] of Object.entries(files)) {
+          if (info.loaded < info.total) {
+            activeFile = file;
+            activeFileProgress = info.total > 0 ? info.loaded / info.total * 100 : 0;
+            break;
           }
         }
-        const unseenTinyFiles = Math.max(0, estimatedTinyFiles - seenTinyCount);
-        const unseenMediumFiles = Math.max(0, estimatedMediumFiles - seenMediumCount);
-        let estimatedLargeFiles;
-        if (seenLargeCount > 0) {
-          estimatedLargeFiles = 2;
-        } else {
-          estimatedLargeFiles = 1;
-        }
-        const unseenLargeFiles = Math.max(0, estimatedLargeFiles - seenLargeCount);
-        const adjustedTotalSize = actualTotalSize + unseenTinyFiles * estimatedTinySize + unseenMediumFiles * estimatedMediumSize + unseenLargeFiles * estimatedLargeSize;
-        const rawProgress = adjustedTotalSize > 0 ? actualLoadedSize / adjustedTotalSize * 100 : 0;
-        const overallProgress = rawProgress * progressScaleMax / 100;
-        const isLast = !fileLastSent.has(file);
-        if (isLast) {
-          fileLastSent.add(file);
-          if (hasSeenSubstantialFile) {
-            sendProgress(overallProgress, file, 100, false, true);
+        if (!activeFile) {
+          const fileNames = Object.keys(files);
+          if (fileNames.length > 0) {
+            activeFile = fileNames[fileNames.length - 1];
+            activeFileProgress = 100;
           }
         }
       }
+      sendProgress(scaledProgress, activeFile, activeFileProgress);
     }
   };
   const pipelineOptions = {
@@ -261,6 +162,18 @@ var doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKe
   logger.time(pipelineTimerLabel, { pipelineType, modelPath });
   try {
     const result = await pipeline(pipelineType, model.provider_config.model_path, pipelineOptions);
+    if (throttleTimer) {
+      clearTimeout(throttleTimer);
+      throttleTimer = null;
+    }
+    const finalPending = pendingProgress;
+    if (finalPending) {
+      onProgress(Math.round(finalPending.progress), "Downloading model", {
+        file: finalPending.file,
+        progress: finalPending.fileProgress
+      });
+      pendingProgress = null;
+    }
     if (abortSignal?.aborted) {
       logger.timeEnd(pipelineTimerLabel, { status: "aborted" });
       throw new Error("Operation aborted after pipeline creation");
@@ -365,12 +278,22 @@ var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
   return { vector: hfVector.data };
 };
 var HFT_TextClassification = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
   if (model?.provider_config?.pipeline === "zero-shot-classification") {
     if (!input.candidateLabels || !Array.isArray(input.candidateLabels) || input.candidateLabels.length === 0) {
       throw new Error("Zero-shot text classification requires candidate labels");
     }
     const zeroShotClassifier = await getPipeline(model, onProgress, {}, signal);
     const result2 = await zeroShotClassifier(input.text, input.candidateLabels, {});
+    if (isArrayInput) {
+      const results = Array.isArray(result2) && Array.isArray(result2[0]?.labels) ? result2 : [result2];
+      return {
+        categories: results.map((r) => r.labels.map((label, idx) => ({
+          label,
+          score: r.scores[idx]
+        })))
+      };
+    }
     return {
       categories: result2.labels.map((label, idx) => ({
         label,
@@ -382,6 +305,17 @@ var HFT_TextClassification = async (input, model, onProgress, signal) => {
   const result = await TextClassification(input.text, {
     top_k: input.maxCategories || undefined
   });
+  if (isArrayInput) {
+    return {
+      categories: result.map((perInput) => {
+        const items = Array.isArray(perInput) ? perInput : [perInput];
+        return items.map((category) => ({
+          label: category.label,
+          score: category.score
+        }));
+      })
+    };
+  }
   if (Array.isArray(result[0])) {
     return {
       categories: result[0].map((category) => ({
@@ -398,10 +332,22 @@ var HFT_TextClassification = async (input, model, onProgress, signal) => {
   };
 };
 var HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
   const TextClassification = await getPipeline(model, onProgress, {}, signal);
   const result = await TextClassification(input.text, {
     top_k: input.maxLanguages || undefined
   });
+  if (isArrayInput) {
+    return {
+      languages: result.map((perInput) => {
+        const items = Array.isArray(perInput) ? perInput : [perInput];
+        return items.map((category) => ({
+          language: category.label,
+          score: category.score
+        }));
+      })
+    };
+  }
   if (Array.isArray(result[0])) {
     return {
       languages: result[0].map((category) => ({
@@ -418,10 +364,23 @@ var HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
   };
 };
 var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
   const textNamedEntityRecognition = await getPipeline(model, onProgress, {}, signal);
-  let results = await textNamedEntityRecognition(input.text, {
+  const results = await textNamedEntityRecognition(input.text, {
     ignore_labels: input.blockList
   });
+  if (isArrayInput) {
+    return {
+      entities: results.map((perInput) => {
+        const items = Array.isArray(perInput) ? perInput : [perInput];
+        return items.map((entity) => ({
+          entity: entity.entity,
+          score: entity.score,
+          word: entity.word
+        }));
+      })
+    };
+  }
   let entities = [];
   if (!Array.isArray(results)) {
     entities = [results];
@@ -437,8 +396,21 @@ var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) =>
   };
 };
 var HFT_TextFillMask = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
   const unmasker = await getPipeline(model, onProgress, {}, signal);
-  let results = await unmasker(input.text);
+  const results = await unmasker(input.text);
+  if (isArrayInput) {
+    return {
+      predictions: results.map((perInput) => {
+        const items = Array.isArray(perInput) ? perInput : [perInput];
+        return items.map((prediction) => ({
+          entity: prediction.token_str,
+          score: prediction.score,
+          sequence: prediction.sequence
+        }));
+      })
+    };
+  }
   let predictions = [];
   if (!Array.isArray(results)) {
     predictions = [results];
@@ -457,15 +429,25 @@ var HFT_TextGeneration = async (input, model, onProgress, signal) => {
   const logger = getLogger();
   const timerLabel = `hft:TextGeneration:${model?.provider_config.model_path}`;
   logger.time(timerLabel, { model: model?.provider_config.model_path });
+  const isArrayInput = Array.isArray(input.prompt);
   const generateText = await getPipeline(model, onProgress, {}, signal);
   logger.debug("HFT TextGeneration: pipeline ready, generating text", {
     model: model?.provider_config.model_path,
-    promptLength: input.prompt?.length
+    promptLength: isArrayInput ? input.prompt.length : input.prompt?.length
   });
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress);
+  const streamer = isArrayInput ? undefined : createTextStreamer(generateText.tokenizer, onProgress);
   let results = await generateText(input.prompt, {
-    streamer
+    ...streamer ? { streamer } : {}
   });
+  if (isArrayInput) {
+    const batchResults = Array.isArray(results) ? results : [results];
+    const texts = batchResults.map((r) => {
+      const seqs = Array.isArray(r) ? r : [r];
+      return extractGeneratedText(seqs[0]?.generated_text);
+    });
+    logger.timeEnd(timerLabel, { batchSize: texts.length });
+    return { text: texts };
+  }
   if (!Array.isArray(results)) {
     results = [results];
   }
@@ -476,13 +458,21 @@ var HFT_TextGeneration = async (input, model, onProgress, signal) => {
   };
 };
 var HFT_TextTranslation = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
   const translate = await getPipeline(model, onProgress, {}, signal);
-  const streamer = createTextStreamer(translate.tokenizer, onProgress);
+  const streamer = isArrayInput ? undefined : createTextStreamer(translate.tokenizer, onProgress);
   const result = await translate(input.text, {
     src_lang: input.source_lang,
     tgt_lang: input.target_lang,
-    streamer
+    ...streamer ? { streamer } : {}
   });
+  if (isArrayInput) {
+    const batchResults = Array.isArray(result) ? result : [result];
+    return {
+      text: batchResults.map((r) => r?.translation_text || ""),
+      target_lang: input.target_lang
+    };
+  }
   const translatedText = Array.isArray(result) ? result[0]?.translation_text || "" : result?.translation_text || "";
   return {
     text: translatedText,
@@ -490,12 +480,29 @@ var HFT_TextTranslation = async (input, model, onProgress, signal) => {
   };
 };
 var HFT_TextRewriter = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
   const generateText = await getPipeline(model, onProgress, {}, signal);
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress);
+  const streamer = isArrayInput ? undefined : createTextStreamer(generateText.tokenizer, onProgress);
+  if (isArrayInput) {
+    const texts = input.text;
+    const promptedTexts = texts.map((t) => (input.prompt ? input.prompt + `
+` : "") + t);
+    let results2 = await generateText(promptedTexts, {});
+    const batchResults = Array.isArray(results2) ? results2 : [results2];
+    const outputTexts = batchResults.map((r, i) => {
+      const seqs = Array.isArray(r) ? r : [r];
+      const text2 = extractGeneratedText(seqs[0]?.generated_text);
+      if (text2 === promptedTexts[i]) {
+        throw new Error("Rewriter failed to generate new text");
+      }
+      return text2;
+    });
+    return { text: outputTexts };
+  }
   const promptedText = (input.prompt ? input.prompt + `
 ` : "") + input.text;
   let results = await generateText(promptedText, {
-    streamer
+    ...streamer ? { streamer } : {}
   });
   if (!Array.isArray(results)) {
     results = [results];
@@ -509,11 +516,18 @@ var HFT_TextRewriter = async (input, model, onProgress, signal) => {
   };
 };
 var HFT_TextSummary = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
   const generateSummary = await getPipeline(model, onProgress, {}, signal);
-  const streamer = createTextStreamer(generateSummary.tokenizer, onProgress);
-  let result = await generateSummary(input.text, {
-    streamer
+  const streamer = isArrayInput ? undefined : createTextStreamer(generateSummary.tokenizer, onProgress);
+  const result = await generateSummary(input.text, {
+    ...streamer ? { streamer } : {}
   });
+  if (isArrayInput) {
+    const batchResults = Array.isArray(result) ? result : [result];
+    return {
+      text: batchResults.map((r) => r?.summary_text || "")
+    };
+  }
   let summaryText = "";
   if (Array.isArray(result)) {
     summaryText = result[0]?.summary_text || "";
@@ -525,7 +539,27 @@ var HFT_TextSummary = async (input, model, onProgress, signal) => {
   };
 };
 var HFT_TextQuestionAnswer = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.question);
   const generateAnswer = await getPipeline(model, onProgress, {}, signal);
+  if (isArrayInput) {
+    const questions = input.question;
+    const contexts = input.context;
+    if (questions.length !== contexts.length) {
+      throw new Error(`question[] and context[] must have the same length: ${questions.length} != ${contexts.length}`);
+    }
+    const answers = [];
+    for (let i = 0;i < questions.length; i++) {
+      const result2 = await generateAnswer(questions[i], contexts[i], {});
+      let answerText2 = "";
+      if (Array.isArray(result2)) {
+        answerText2 = result2[0]?.answer || "";
+      } else {
+        answerText2 = result2?.answer || "";
+      }
+      answers.push(answerText2);
+    }
+    return { text: answers };
+  }
   const streamer = createTextStreamer(generateAnswer.tokenizer, onProgress);
   const result = await generateAnswer(input.question, input.context, {
     streamer
@@ -884,10 +918,16 @@ var HFT_TextTranslation_Stream = async function* (input, model, signal) {
   yield { type: "finish", data: { target_lang: input.target_lang } };
 };
 var HFT_CountTokens = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.text);
   const { AutoTokenizer } = _transformersSdk;
   const tokenizer = await AutoTokenizer.from_pretrained(model.provider_config.model_path, {
     progress_callback: (progress) => onProgress(progress?.progress ?? 0)
   });
+  if (isArrayInput) {
+    const texts = input.text;
+    const counts = texts.map((t) => tokenizer.encode(t).length);
+    return { count: counts };
+  }
   const tokenIds = tokenizer.encode(input.text);
   return { count: tokenIds.length };
 };
@@ -1034,7 +1074,40 @@ ${requiredInstruction}` };
   return mapHFTTools(input.tools);
 }
 var HFT_ToolCalling = async (input, model, onProgress, signal) => {
+  const isArrayInput = Array.isArray(input.prompt);
   const generateText = await getPipeline(model, onProgress, {}, signal);
+  if (isArrayInput) {
+    const prompts = input.prompt;
+    const texts = [];
+    const allToolCalls = [];
+    for (const promptText of prompts) {
+      const messages2 = [];
+      if (input.systemPrompt) {
+        messages2.push({ role: "system", content: input.systemPrompt });
+      }
+      messages2.push({ role: "user", content: promptText });
+      const singleInput = { ...input, prompt: promptText };
+      const tools2 = resolveHFTToolsAndMessages(singleInput, messages2);
+      const prompt2 = generateText.tokenizer.apply_chat_template(messages2, {
+        tools: tools2,
+        tokenize: false,
+        add_generation_prompt: true
+      });
+      let results2 = await generateText(prompt2, {
+        max_new_tokens: input.maxTokens ?? 1024,
+        temperature: input.temperature ?? undefined,
+        return_full_text: false
+      });
+      if (!Array.isArray(results2)) {
+        results2 = [results2];
+      }
+      const responseText2 = extractGeneratedText(results2[0]?.generated_text).trim();
+      const parsed = parseToolCallsFromText(responseText2);
+      texts.push(parsed.text);
+      allToolCalls.push(filterValidToolCalls(parsed.toolCalls, input.tools));
+    }
+    return { text: texts, toolCalls: allToolCalls };
+  }
   const messages = [];
   if (input.systemPrompt) {
     messages.push({ role: "system", content: input.systemPrompt });
@@ -1122,33 +1195,47 @@ var HFT_ToolCalling_Stream = async function* (input, model, signal) {
   };
 };
 var HFT_ModelInfo = async (input, model) => {
+  const logger = getLogger();
+  const { ModelRegistry } = await loadTransformersSDK();
+  const timerLabel = `hft:ModelInfo:${model?.provider_config.model_path}`;
+  logger.time(timerLabel, { model: model?.provider_config.model_path });
+  const detail = input.detail;
   const is_loaded = pipelines.has(getPipelineCacheKey(model));
-  let is_cached = is_loaded;
-  let file_sizes = null;
-  if (typeof caches !== "undefined") {
-    try {
-      const cache = await caches.open(HTF_CACHE_NAME);
-      const keys = await cache.keys();
-      const model_path = model.provider_config.model_path;
-      const prefix = `/${model_path}/`;
-      const sizes = {};
-      for (const request of keys) {
-        const url = new URL(request.url);
-        if (url.pathname.startsWith(prefix)) {
-          is_cached = true;
-          const response = await cache.match(request);
-          const contentLength = response?.headers.get("Content-Length");
-          if (contentLength) {
-            const filename = url.pathname.slice(prefix.length);
-            sizes[filename] = parseInt(contentLength, 10);
-          }
-        }
+  const { pipeline: pipelineType, model_path, dtype, device } = model.provider_config;
+  const cacheStatus = await ModelRegistry.is_pipeline_cached(pipelineType, model_path, {
+    ...dtype ? { dtype } : {}
+  });
+  logger.debug("is_pipeline_cached", {
+    input: [
+      pipelineType,
+      model_path,
+      {
+        ...dtype ? { dtype } : {}
       }
-      if (Object.keys(sizes).length > 0) {
-        file_sizes = sizes;
+    ],
+    result: cacheStatus
+  });
+  const is_cached = is_loaded || cacheStatus.allCached;
+  let file_sizes = null;
+  if (detail === "files" && cacheStatus.files.length > 0) {
+    const sizes = {};
+    for (const { file } of cacheStatus.files) {
+      sizes[file] = 0;
+    }
+    file_sizes = sizes;
+  } else if (detail === "files_with_metadata" && cacheStatus.files.length > 0) {
+    const sizes = {};
+    await Promise.all(cacheStatus.files.map(async ({ file }) => {
+      const metadata = await ModelRegistry.get_file_metadata(model_path, file);
+      if (metadata.exists && metadata.size !== undefined) {
+        sizes[file] = metadata.size;
       }
-    } catch {}
+    }));
+    if (Object.keys(sizes).length > 0) {
+      file_sizes = sizes;
+    }
   }
+  logger.timeEnd(timerLabel, { model: model?.provider_config.model_path });
   return {
     model: input.model,
     is_local: true,
@@ -1197,4 +1284,4 @@ var HFT_REACTIVE_TASKS = {
 
 export { clearPipelineCache, HFT_Download, HFT_Unload, HFT_TextEmbedding, HFT_TextClassification, HFT_TextLanguageDetection, HFT_TextNamedEntityRecognition, HFT_TextFillMask, HFT_TextGeneration, HFT_TextTranslation, HFT_TextRewriter, HFT_TextSummary, HFT_TextQuestionAnswer, HFT_ImageSegmentation, HFT_ImageToText, HFT_BackgroundRemoval, HFT_ImageEmbedding, HFT_ImageClassification, HFT_ObjectDetection, createToolCallMarkupFilter, HFT_TextGeneration_Stream, HFT_TextRewriter_Stream, HFT_TextSummary_Stream, HFT_TextQuestionAnswer_Stream, HFT_TextTranslation_Stream, HFT_CountTokens, HFT_CountTokens_Reactive, parseToolCallsFromText, HFT_ToolCalling, HFT_ToolCalling_Stream, HFT_ModelInfo, HFT_TASKS, HFT_STREAM_TASKS, HFT_REACTIVE_TASKS };
 
-//# debugId=DC966EB934582FEF64756E2164756E21
+//# debugId=35AEEC521C026A1E64756E2164756E21