@workglow/ai-provider 0.0.126 → 0.1.0

package/dist/provider-hf-transformers/runtime.js

@@ -30,7 +30,8 @@ __export(exports_HFT_Pipeline, {
   hasCachedPipeline: () => hasCachedPipeline,
   getPipelineCacheKey: () => getPipelineCacheKey,
   getPipeline: () => getPipeline,
-  clearPipelineCache: () => clearPipelineCache
+  clearPipelineCache: () => clearPipelineCache,
+  HFT_NULL_PROCESSOR_PREFIX: () => HFT_NULL_PROCESSOR_PREFIX
 });
 import { getLogger } from "@workglow/util/worker";
 function setHftCacheDir(dir) {
@@ -53,18 +54,99 @@ async function loadTransformersSDK() {
   }
   return _transformersSdk;
 }
+function combineAbortSignals(existingSignal, modelSignal) {
+  if (!existingSignal) {
+    return modelSignal;
+  }
+  if (!modelSignal) {
+    return existingSignal;
+  }
+  if (existingSignal.aborted || modelSignal.aborted) {
+    return AbortSignal.abort(existingSignal.reason ?? modelSignal.reason);
+  }
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([existingSignal, modelSignal]);
+  }
+  const controller = new AbortController;
+  const abort = (event) => {
+    const signal = event.target;
+    controller.abort(signal.reason);
+  };
+  existingSignal.addEventListener("abort", abort, { once: true });
+  modelSignal.addEventListener("abort", abort, { once: true });
+  return controller.signal;
+}
+function createAbortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    return reason;
+  }
+  return new Error(String(reason ?? "Fetch aborted"));
+}
+function wrapAbortableResponse(response, signal) {
+  if (!signal || !response.body) {
+    return response;
+  }
+  const contentLengthHeader = response.headers.get("content-length");
+  const expectedSize = contentLengthHeader && /^\d+$/.test(contentLengthHeader) ? Number.parseInt(contentLengthHeader, 10) : undefined;
+  const sourceBody = response.body;
+  const body = new ReadableStream({
+    async start(controller) {
+      const reader = sourceBody.getReader();
+      const abort = () => controller.error(createAbortError(signal));
+      signal.addEventListener("abort", abort, { once: true });
+      let loaded = 0;
+      try {
+        while (true) {
+          if (signal.aborted) {
+            throw createAbortError(signal);
+          }
+          const { done, value } = await reader.read();
+          if (done) {
+            if (signal.aborted) {
+              throw createAbortError(signal);
+            }
+            if (expectedSize !== undefined && loaded < expectedSize) {
+              throw new Error(`Fetch ended before reading the full response body (${loaded}/${expectedSize} bytes)`);
+            }
+            controller.close();
+            return;
+          }
+          loaded += value.length;
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        signal.removeEventListener("abort", abort);
+        reader.releaseLock();
+      }
+    },
+    async cancel(reason) {
+      try {
+        await sourceBody.cancel(reason);
+      } catch {}
+    }
+  });
+  return new Response(body, {
+    headers: new Headers(response.headers),
+    status: response.status,
+    statusText: response.statusText
+  });
+}
 function abortableFetch(url, options) {
-  let signal;
+  let modelSignal;
   try {
     const pathname = new URL(url).pathname;
     for (const [modelPath, controller] of modelAbortControllers) {
       if (pathname.includes(`/${modelPath}/`)) {
-        signal = controller.signal;
+        modelSignal = controller.signal;
         break;
       }
     }
   } catch {}
-  return fetch(url, { ...options, ...signal ? { signal } : {} });
+  const combinedSignal = combineAbortSignals(options.signal, modelSignal);
+  return fetch(url, { ...options, ...combinedSignal ? { signal: combinedSignal } : {} }).then((response) => wrapAbortableResponse(response, combinedSignal));
 }
 function clearPipelineCache() {
   pipelines.clear();
@@ -85,9 +167,10 @@ function isBrowserEnv() {
   return false;
 }
 function getPipelineCacheKey(model) {
-  const dtype = model.provider_config.dtype || "q8";
+  const dtype = model.provider_config.dtype || "";
   const device = model.provider_config.device || "";
-  return `${model.provider_config.model_path}:${model.provider_config.pipeline}:${dtype}:${device}`;
+  const revision = model.provider_config.revision || "main";
+  return `${model.provider_config.model_path}:${model.provider_config.pipeline}:${dtype}:${device}:${revision}`;
 }
 async function getPipeline(model, onProgress, options = {}, signal, progressScaleMax = 10) {
   const cacheKey = getPipelineCacheKey(model);
@@ -108,7 +191,7 @@ async function getPipeline(model, onProgress, options = {}, signal, progressScal
   pipelineLoadPromises.set(cacheKey, loadPromise);
   return loadPromise;
 }
-var _transformersSdk, _cacheDir, modelAbortControllers, pipelines, pipelineLoadPromises, doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKey, signal) => {
+var _transformersSdk, _cacheDir, modelAbortControllers, pipelines, pipelineLoadPromises, IMAGE_PIPELINE_TYPES, HFT_NULL_PROCESSOR_PREFIX = "HFT_NULL_PROCESSOR:", doGetPipeline = async (model, onProgress, options, progressScaleMax, cacheKey, signal) => {
   let lastProgressTime = 0;
   let pendingProgress = null;
   let throttleTimer = null;
@@ -206,16 +289,18 @@ var _transformersSdk, _cacheDir, modelAbortControllers, pipelines, pipelineLoadP
       device = "wasm";
     }
     if (device !== "wasm" && device !== "webgpu") {
-      device = "webgpu";
+      device = "wasm";
     }
   } else {
     if (device === "wasm" || device === "webgpu") {
       device = undefined;
     }
   }
+  const dtype = model.provider_config.dtype || "";
   const pipelineOptions = {
-    dtype: model.provider_config.dtype || "q8",
+    revision: model.provider_config.revision || "main",
     ...model.provider_config.use_external_data_format ? { useExternalDataFormat: model.provider_config.use_external_data_format } : {},
+    ...dtype ? { dtype } : {},
     ...device ? { device } : {},
     ...options,
     progress_callback: progressCallback
@@ -244,27 +329,44 @@ var _transformersSdk, _cacheDir, modelAbortControllers, pipelines, pipelineLoadP
       logger.timeEnd(pipelineTimerLabel, { status: "aborted" });
       throw new Error("Operation aborted after pipeline creation");
     }
+    if (IMAGE_PIPELINE_TYPES.has(pipelineType) && result.processor == null) {
+      throw new Error(`${HFT_NULL_PROCESSOR_PREFIX} Image processor not initialized for ${pipelineType}/${modelPath}. Model cache may be incomplete.`);
+    }
     logger.timeEnd(pipelineTimerLabel, { status: "loaded" });
     pipelines.set(cacheKey, result);
     return result;
   } catch (error) {
     logger.timeEnd(pipelineTimerLabel, { status: "error", error: String(error) });
-    if (abortSignal?.aborted || modelController.signal.aborted) {
+    if (!error?.message?.startsWith(HFT_NULL_PROCESSOR_PREFIX) && (abortSignal?.aborted || modelController.signal.aborted)) {
       throw new Error("Pipeline download aborted");
     }
     throw error;
   } finally {
     modelAbortControllers.delete(modelPath);
+    const { random } = await loadTransformersSDK();
+    random.seed(model.provider_config.seed ?? undefined);
   }
 };
 var init_HFT_Pipeline = __esm(() => {
   modelAbortControllers = new Map;
   pipelines = new Map;
   pipelineLoadPromises = new Map;
+  IMAGE_PIPELINE_TYPES = new Set([
+    "image-classification",
+    "image-segmentation",
+    "object-detection",
+    "image-to-text",
+    "image-feature-extraction",
+    "zero-shot-image-classification",
+    "depth-estimation",
+    "mask-generation"
+  ]);
 });
 
 // src/provider-hf-transformers/common/HFT_Constants.ts
 var HF_TRANSFORMERS_ONNX = "HF_TRANSFORMERS_ONNX";
+var HF_TRANSFORMERS_ONNX_GPU = `${HF_TRANSFORMERS_ONNX}_gpu`;
+var HF_TRANSFORMERS_ONNX_CPU = `${HF_TRANSFORMERS_ONNX}_cpu`;
 var HTF_CACHE_NAME = "transformers-cache";
 var QuantizationDataType = {
   auto: "auto",
@@ -340,6 +442,11 @@ var HfTransformersOnnxModelSchema = {
           type: "string",
           description: "Filesystem path or URI for the ONNX model."
         },
+        revision: {
+          type: "string",
+          description: "Git revision (branch, tag, or commit hash) of the model repository.",
+          default: "main"
+        },
         dtype: {
           type: "string",
           enum: Object.values(QuantizationDataType),
@@ -389,6 +496,11 @@ var HfTransformersOnnxModelSchema = {
           type: "string",
           description: "The language style of the model."
         },
+        seed: {
+          type: "integer",
+          description: "RNG seed passed to transformers.js sampling. Omit for time-based seeding; set for reproducible generation.",
+          minimum: 0
+        },
         mrl: {
           type: "boolean",
           description: "Whether the model uses matryoshka.",
@@ -487,178 +599,6 @@ function parseOnnxQuantizations(params) {
     return set !== undefined && set.size === allBaseNames.size;
   });
 }
-// src/provider-hf-transformers/common/HFT_ToolMarkup.ts
-function parseToolCallsFromText(responseText) {
-  const toolCalls = [];
-  let callIndex = 0;
-  let cleanedText = responseText;
-  const toolCallTagRegex = /<tool_call>([\s\S]*?)<\/tool_call>/g;
-  let tagMatch;
-  while ((tagMatch = toolCallTagRegex.exec(responseText)) !== null) {
-    try {
-      const parsed = JSON.parse(tagMatch[1].trim());
-      const id = `call_${callIndex++}`;
-      toolCalls.push({
-        id,
-        name: parsed.name ?? parsed.function?.name ?? "",
-        input: parsed.arguments ?? parsed.function?.arguments ?? parsed.parameters ?? {}
-      });
-    } catch {}
-  }
-  if (toolCalls.length > 0) {
-    cleanedText = responseText.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "").trim();
-    return { text: cleanedText, toolCalls };
-  }
-  const jsonCandidates = [];
-  (function collectBalancedJsonBlocks(source) {
-    const length = source.length;
-    let i = 0;
-    while (i < length) {
-      if (source[i] !== "{") {
-        i++;
-        continue;
-      }
-      let depth = 1;
-      let j = i + 1;
-      let inString = false;
-      let escape = false;
-      while (j < length && depth > 0) {
-        const ch = source[j];
-        if (inString) {
-          if (escape) {
-            escape = false;
-          } else if (ch === "\\") {
-            escape = true;
-          } else if (ch === '"') {
-            inString = false;
-          }
-        } else {
-          if (ch === '"') {
-            inString = true;
-          } else if (ch === "{") {
-            depth++;
-          } else if (ch === "}") {
-            depth--;
-          }
-        }
-        j++;
-      }
-      if (depth === 0) {
-        jsonCandidates.push({ text: source.slice(i, j), start: i, end: j });
-        i = j;
-      } else {
-        break;
-      }
-    }
-  })(responseText);
-  const matchedRanges = [];
-  for (const candidate of jsonCandidates) {
-    try {
-      const parsed = JSON.parse(candidate.text);
-      if (parsed.name && (parsed.arguments !== undefined || parsed.parameters !== undefined)) {
-        const id = `call_${callIndex++}`;
-        toolCalls.push({
-          id,
-          name: parsed.name,
-          input: parsed.arguments ?? parsed.parameters ?? {}
-        });
-        matchedRanges.push({ start: candidate.start, end: candidate.end });
-      } else if (parsed.function?.name) {
-        let functionArgs = parsed.function.arguments ?? {};
-        if (typeof functionArgs === "string") {
-          try {
-            functionArgs = JSON.parse(functionArgs);
-          } catch (innerError) {
-            console.warn("Failed to parse tool call function.arguments as JSON", innerError);
-            functionArgs = {};
-          }
-        }
-        const id = `call_${callIndex++}`;
-        toolCalls.push({
-          id,
-          name: parsed.function.name,
-          input: functionArgs ?? {}
-        });
-        matchedRanges.push({ start: candidate.start, end: candidate.end });
-      }
-    } catch {}
-  }
-  if (toolCalls.length > 0) {
-    let result = "";
-    let lastIndex = 0;
-    for (const range of matchedRanges) {
-      result += responseText.slice(lastIndex, range.start);
-      lastIndex = range.end;
-    }
-    result += responseText.slice(lastIndex);
-    cleanedText = result.trim();
-  }
-  return { text: cleanedText, toolCalls };
-}
-function createToolCallMarkupFilter(emit) {
-  const OPEN_TAG = "<tool_call>";
-  const CLOSE_TAG = "</tool_call>";
-  let state = "text";
-  let pending = "";
-  function feed(token) {
-    if (state === "tag") {
-      pending += token;
-      const closeIdx = pending.indexOf(CLOSE_TAG);
-      if (closeIdx !== -1) {
-        const afterClose = pending.slice(closeIdx + CLOSE_TAG.length);
-        pending = "";
-        state = "text";
-        if (afterClose.length > 0) {
-          feed(afterClose);
-        }
-      }
-      return;
-    }
-    const combined = pending + token;
-    const openIdx = combined.indexOf(OPEN_TAG);
-    if (openIdx !== -1) {
-      const before = combined.slice(0, openIdx);
-      if (before.length > 0) {
-        emit(before);
-      }
-      pending = "";
-      state = "tag";
-      const afterOpen = combined.slice(openIdx + OPEN_TAG.length);
-      if (afterOpen.length > 0) {
-        feed(afterOpen);
-      }
-      return;
-    }
-    let prefixLen = 0;
-    for (let len = Math.min(combined.length, OPEN_TAG.length - 1);len >= 1; len--) {
-      if (combined.endsWith(OPEN_TAG.slice(0, len))) {
-        prefixLen = len;
-        break;
-      }
-    }
-    if (prefixLen > 0) {
-      const safe = combined.slice(0, combined.length - prefixLen);
-      if (safe.length > 0) {
-        emit(safe);
-      }
-      pending = combined.slice(combined.length - prefixLen);
-    } else {
-      if (combined.length > 0) {
-        emit(combined);
-      }
-      pending = "";
-    }
-  }
-  function flush() {
-    if (pending.length > 0 && state === "text") {
-      emit(pending);
-      pending = "";
-    }
-    pending = "";
-    state = "text";
-  }
-  return { feed, flush };
-}
 // src/provider-hf-transformers/common/HFT_InlineLifecycle.ts
 async function clearHftInlinePipelineCache() {
   const { clearPipelineCache: clearPipelineCache2 } = await Promise.resolve().then(() => (init_HFT_Pipeline(), exports_HFT_Pipeline));
@@ -792,16 +732,10 @@ var HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
 // src/provider-hf-transformers/common/HFT_CountTokens.ts
 init_HFT_Pipeline();
 var HFT_CountTokens = async (input, model, onProgress, _signal) => {
-  const isArrayInput = Array.isArray(input.text);
   const { AutoTokenizer } = await loadTransformersSDK();
   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 };
 };
@@ -865,6 +799,15 @@ var HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
   logger.debug("HFT ImageEmbedding: pipeline ready, generating embedding", {
     model: model?.provider_config.model_path
   });
+  if (Array.isArray(input.image)) {
+    const vectors = [];
+    for (const image of input.image) {
+      const result2 = await embedder(image);
+      vectors.push(result2.data);
+    }
+    logger.timeEnd(timerLabel, { count: vectors.length });
+    return { vector: vectors };
+  }
   const result = await embedder(input.image);
   logger.timeEnd(timerLabel, { dimensions: result?.data?.length });
   return {
@@ -914,18 +857,14 @@ var HFT_ModelInfo = async (input, model) => {
   logger.time(timerLabel, { model: model?.provider_config.model_path });
   const detail = input.detail;
   const is_loaded = hasCachedPipeline(getPipelineCacheKey(model));
-  const { pipeline: pipelineType, model_path, dtype } = model.provider_config;
-  const cacheStatus = await ModelRegistry.is_pipeline_cached_files(pipelineType, model_path, {
-    ...dtype ? { dtype } : {}
-  });
+  const { pipeline: pipelineType, model_path, dtype, device } = model.provider_config;
+  const cacheOptions = {
+    ...dtype ? { dtype } : {},
+    ...device ? { device } : {}
+  };
+  const cacheStatus = await ModelRegistry.is_pipeline_cached_files(pipelineType, model_path, cacheOptions);
   logger.debug("is_pipeline_cached", {
-    input: [
-      pipelineType,
-      model_path,
-      {
-        ...dtype ? { dtype } : {}
-      }
-    ],
+    input: [pipelineType, model_path, cacheOptions],
     result: cacheStatus
   });
   const is_cached = is_loaded || cacheStatus.allCached;
@@ -1009,6 +948,7 @@ init_HFT_Pipeline();
 import { parsePartialJson } from "@workglow/util/worker";
 
 // src/provider-hf-transformers/common/HFT_Streaming.ts
+import { TaskAbortedError } from "@workglow/task-graph";
 function createStreamEventQueue() {
   const buffer = [];
   let resolve = null;
@@ -1060,21 +1000,27 @@ function createStreamEventQueue() {
   };
   return { push, done, error, iterable };
 }
-function createStreamingTextStreamer(tokenizer, queue, textStreamer) {
+function createStreamingTextStreamer(tokenizer, queue, textStreamer, signal) {
   return new textStreamer(tokenizer, {
     skip_prompt: true,
     decode_kwargs: { skip_special_tokens: true },
     callback_function: (text) => {
+      if (signal?.aborted) {
+        throw signal.reason ?? new TaskAbortedError("Generation aborted");
+      }
       queue.push({ type: "text-delta", port: "text", textDelta: text });
     }
   });
 }
-function createTextStreamer(tokenizer, updateProgress, textStreamer) {
+function createTextStreamer(tokenizer, updateProgress, textStreamer, signal) {
   let count = 0;
   return new textStreamer(tokenizer, {
     skip_prompt: true,
     decode_kwargs: { skip_special_tokens: true },
     callback_function: (text) => {
+      if (signal?.aborted) {
+        throw signal.reason ?? new TaskAbortedError("Generation aborted");
+      }
       count++;
       const result = 100 * (1 - Math.exp(-0.05 * count));
       const progress = Math.round(Math.min(result, 100));
@@ -1137,7 +1083,7 @@ var HFT_StructuredGeneration = async (input, model, onProgress, signal) => {
     tokenize: false,
     add_generation_prompt: true
   });
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer, signal);
   let results = await generateText(formattedPrompt, {
     max_new_tokens: input.maxTokens ?? 1024,
     temperature: input.temperature ?? undefined,
@@ -1162,7 +1108,7 @@ var HFT_StructuredGeneration_Stream = async function* (input, model, signal) {
     add_generation_prompt: true
   });
   const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer, signal);
   let fullText = "";
   const originalPush = queue.push;
   queue.push = (event) => {
@@ -1198,22 +1144,12 @@ var HFT_StructuredGeneration_Stream = async function* (input, model, signal) {
 // src/provider-hf-transformers/common/HFT_TextClassification.ts
 init_HFT_Pipeline();
 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,
@@ -1225,27 +1161,9 @@ 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) => ({
-        label: category.label,
-        score: category.score
-      }))
-    };
-  }
+  const items = Array.isArray(result[0]) ? result[0] : result;
   return {
-    categories: result.map((category) => ({
+    categories: items.map((category) => ({
       label: category.label,
       score: category.score
     }))
@@ -1295,21 +1213,8 @@ var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
 // src/provider-hf-transformers/common/HFT_TextFillMask.ts
 init_HFT_Pipeline();
 var HFT_TextFillMask = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
   const unmasker = await getPipeline(model, onProgress, {}, signal);
   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];
@@ -1332,26 +1237,16 @@ var HFT_TextGeneration = async (input, model, onProgress, signal) => {
   const logger = getLogger6();
   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);
   const { TextStreamer } = await loadTransformersSDK();
   logger.debug("HFT TextGeneration: pipeline ready, generating text", {
     model: model?.provider_config.model_path,
-    promptLength: isArrayInput ? input.prompt.length : input.prompt?.length
+    promptLength: input.prompt?.length
   });
-  const streamer = isArrayInput ? undefined : createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
+  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer, signal);
   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];
   }
@@ -1366,7 +1261,7 @@ var HFT_TextGeneration_Stream = async function* (input, model, signal) {
   const generateText = await getPipeline(model, noopProgress, {}, signal);
   const { TextStreamer } = await loadTransformersSDK();
   const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer, signal);
   const pipelinePromise = generateText(input.prompt, {
     streamer
   }).then(() => queue.done(), (err) => queue.error(err));
@@ -1378,22 +1273,10 @@ var HFT_TextGeneration_Stream = async function* (input, model, signal) {
 // src/provider-hf-transformers/common/HFT_TextLanguageDetection.ts
 init_HFT_Pipeline();
 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) => ({
@@ -1413,23 +1296,10 @@ var HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
 // src/provider-hf-transformers/common/HFT_TextNamedEntityRecognition.ts
 init_HFT_Pipeline();
 var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
   const textNamedEntityRecognition = await getPipeline(model, onProgress, {}, signal);
   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];
@@ -1448,29 +1318,9 @@ var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) =>
 // src/provider-hf-transformers/common/HFT_TextQuestionAnswer.ts
 init_HFT_Pipeline();
 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 { TextStreamer } = await loadTransformersSDK();
-  const streamer = createTextStreamer(generateAnswer.tokenizer, onProgress, TextStreamer);
+  const streamer = createTextStreamer(generateAnswer.tokenizer, onProgress, TextStreamer, signal);
   const result = await generateAnswer(input.question, input.context, {
     streamer
   });
@@ -1489,7 +1339,7 @@ var HFT_TextQuestionAnswer_Stream = async function* (input, model, signal) {
   const generateAnswer = await getPipeline(model, noopProgress, {}, signal);
   const { TextStreamer } = await loadTransformersSDK();
   const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, queue, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, queue, TextStreamer, signal);
   let pipelineResult;
   const pipelinePromise = generateAnswer(input.question, input.context, {
     streamer
@@ -1513,30 +1363,13 @@ var HFT_TextQuestionAnswer_Stream = async function* (input, model, signal) {
 // src/provider-hf-transformers/common/HFT_TextRewriter.ts
 init_HFT_Pipeline();
 var HFT_TextRewriter = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
   const generateText = await getPipeline(model, onProgress, {}, signal);
   const { TextStreamer } = await loadTransformersSDK();
-  const streamer = isArrayInput ? undefined : createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
-  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 streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer, signal);
   const promptedText = (input.prompt ? input.prompt + `
 ` : "") + input.text;
   let results = await generateText(promptedText, {
-    ...streamer ? { streamer } : {}
+    streamer
   });
   if (!Array.isArray(results)) {
     results = [results];
@@ -1554,7 +1387,7 @@ var HFT_TextRewriter_Stream = async function* (input, model, signal) {
   const generateText = await getPipeline(model, noopProgress, {}, signal);
   const { TextStreamer } = await loadTransformersSDK();
   const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer, signal);
   const promptedText = (input.prompt ? input.prompt + `
 ` : "") + input.text;
   const pipelinePromise = generateText(promptedText, {
@@ -1568,19 +1401,12 @@ var HFT_TextRewriter_Stream = async function* (input, model, signal) {
 // src/provider-hf-transformers/common/HFT_TextSummary.ts
 init_HFT_Pipeline();
 var HFT_TextSummary = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
   const generateSummary = await getPipeline(model, onProgress, {}, signal);
   const { TextStreamer } = await loadTransformersSDK();
-  const streamer = isArrayInput ? undefined : createTextStreamer(generateSummary.tokenizer, onProgress, TextStreamer);
+  const streamer = createTextStreamer(generateSummary.tokenizer, onProgress, TextStreamer, signal);
   const result = await generateSummary(input.text, {
-    ...streamer ? { 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 || "";
@@ -1596,7 +1422,7 @@ var HFT_TextSummary_Stream = async function* (input, model, signal) {
   const generateSummary = await getPipeline(model, noopProgress, {}, signal);
   const { TextStreamer } = await loadTransformersSDK();
   const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, queue, TextStreamer);
+  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, queue, TextStreamer, signal);
   const pipelinePromise = generateSummary(input.text, {
     streamer
   }).then(() => queue.done(), (err) => queue.error(err));
@@ -1608,22 +1434,14 @@ var HFT_TextSummary_Stream = async function* (input, model, signal) {
 // src/provider-hf-transformers/common/HFT_TextTranslation.ts
 init_HFT_Pipeline();
 var HFT_TextTranslation = async (input, model, onProgress, signal) => {
-  const isArrayInput = Array.isArray(input.text);
   const translate = await getPipeline(model, onProgress, {}, signal);
   const { TextStreamer } = await loadTransformersSDK();
-  const streamer = isArrayInput ? undefined : createTextStreamer(translate.tokenizer, onProgress, TextStreamer);
+  const streamer = createTextStreamer(translate.tokenizer, onProgress, TextStreamer, signal);
   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,
@@ -1635,7 +1453,7 @@ var HFT_TextTranslation_Stream = async function* (input, model, signal) {
   const translate = await getPipeline(model, noopProgress, {}, signal);
   const { TextStreamer } = await loadTransformersSDK();
   const queue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(translate.tokenizer, queue, TextStreamer);
+  const streamer = createStreamingTextStreamer(translate.tokenizer, queue, TextStreamer, signal);
   const pipelinePromise = translate(input.text, {
     src_lang: input.source_lang,
     tgt_lang: input.target_lang,
@@ -1646,162 +1464,6 @@ var HFT_TextTranslation_Stream = async function* (input, model, signal) {
   yield { type: "finish", data: { target_lang: input.target_lang } };
 };
 
-// src/provider-hf-transformers/common/HFT_ToolCalling.ts
-init_HFT_Pipeline();
-import {
-  buildToolDescription,
-  filterValidToolCalls,
-  toTextFlatMessages
-} from "@workglow/ai/worker";
-function mapHFTTools(tools) {
-  return tools.map((t) => ({
-    type: "function",
-    function: {
-      name: t.name,
-      description: buildToolDescription(t),
-      parameters: t.inputSchema
-    }
-  }));
-}
-function resolveHFTToolsAndMessages(input, messages) {
-  if (input.toolChoice === "none") {
-    return;
-  }
-  if (input.toolChoice === "required") {
-    const requiredInstruction = "You must call at least one tool from the provided tool list when answering.";
-    if (messages.length > 0 && messages[0].role === "system") {
-      messages[0] = { ...messages[0], content: `${messages[0].content}
-
-${requiredInstruction}` };
-    } else {
-      messages.unshift({ role: "system", content: requiredInstruction });
-    }
-    return mapHFTTools(input.tools);
-  }
-  if (typeof input.toolChoice === "string" && input.toolChoice !== "auto") {
-    const selectedTools = input.tools?.filter((tool) => tool.name === input.toolChoice);
-    const toolsToMap = selectedTools && selectedTools.length > 0 ? selectedTools : input.tools;
-    return mapHFTTools(toolsToMap);
-  }
-  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);
-  const { TextStreamer } = await loadTransformersSDK();
-  if (isArrayInput) {
-    const prompts = input.prompt;
-    const texts = [];
-    const toolCallsList = [];
-    for (const singlePrompt of prompts) {
-      const singleInput = { ...input, prompt: singlePrompt };
-      const messages2 = toTextFlatMessages(singleInput);
-      const tools2 = resolveHFTToolsAndMessages(singleInput, messages2);
-      const prompt2 = generateText.tokenizer.apply_chat_template(messages2, {
-        tools: tools2,
-        tokenize: false,
-        add_generation_prompt: true
-      });
-      const streamer2 = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
-      let results2 = await generateText(prompt2, {
-        max_new_tokens: input.maxTokens ?? 1024,
-        temperature: input.temperature ?? undefined,
-        return_full_text: false,
-        streamer: streamer2
-      });
-      if (!Array.isArray(results2)) {
-        results2 = [results2];
-      }
-      const responseText2 = extractGeneratedText(results2[0]?.generated_text).trim();
-      const { text: text2, toolCalls: toolCalls2 } = parseToolCallsFromText(responseText2);
-      texts.push(text2);
-      toolCallsList.push(filterValidToolCalls(toolCalls2, singleInput.tools));
-    }
-    return { text: texts, toolCalls: toolCallsList };
-  }
-  const messages = toTextFlatMessages(input);
-  const tools = resolveHFTToolsAndMessages(input, messages);
-  const prompt = generateText.tokenizer.apply_chat_template(messages, {
-    tools,
-    tokenize: false,
-    add_generation_prompt: true
-  });
-  const streamer = createTextStreamer(generateText.tokenizer, onProgress, TextStreamer);
-  let results = await generateText(prompt, {
-    max_new_tokens: input.maxTokens ?? 1024,
-    temperature: input.temperature ?? undefined,
-    return_full_text: false,
-    streamer
-  });
-  if (!Array.isArray(results)) {
-    results = [results];
-  }
-  const responseText = extractGeneratedText(results[0]?.generated_text).trim();
-  const { text, toolCalls } = parseToolCallsFromText(responseText);
-  return {
-    text,
-    toolCalls: filterValidToolCalls(toolCalls, input.tools)
-  };
-};
-var HFT_ToolCalling_Stream = async function* (input, model, signal) {
-  const noopProgress = () => {};
-  const generateText = await getPipeline(model, noopProgress, {}, signal);
-  const { TextStreamer } = await loadTransformersSDK();
-  const messages = toTextFlatMessages(input);
-  const tools = resolveHFTToolsAndMessages(input, messages);
-  const prompt = generateText.tokenizer.apply_chat_template(messages, {
-    tools,
-    tokenize: false,
-    add_generation_prompt: true
-  });
-  const innerQueue = createStreamEventQueue();
-  const outerQueue = createStreamEventQueue();
-  const streamer = createStreamingTextStreamer(generateText.tokenizer, innerQueue, TextStreamer);
-  let fullText = "";
-  const filter = createToolCallMarkupFilter((text) => {
-    outerQueue.push({ type: "text-delta", port: "text", textDelta: text });
-  });
-  const originalPush = innerQueue.push;
-  innerQueue.push = (event) => {
-    if (event.type === "text-delta" && "textDelta" in event) {
-      fullText += event.textDelta;
-      filter.feed(event.textDelta);
-    } else {
-      outerQueue.push(event);
-    }
-    originalPush(event);
-  };
-  const originalDone = innerQueue.done;
-  innerQueue.done = () => {
-    filter.flush();
-    outerQueue.done();
-    originalDone();
-  };
-  const originalError = innerQueue.error;
-  innerQueue.error = (e) => {
-    filter.flush();
-    outerQueue.error(e);
-    originalError(e);
-  };
-  const pipelinePromise = generateText(prompt, {
-    max_new_tokens: input.maxTokens ?? 1024,
-    temperature: input.temperature ?? undefined,
-    return_full_text: false,
-    streamer
-  }).then(() => innerQueue.done(), (err) => innerQueue.error(err));
-  yield* outerQueue.iterable;
-  await pipelinePromise;
-  const { text: cleanedText, toolCalls } = parseToolCallsFromText(fullText);
-  const validToolCalls = filterValidToolCalls(toolCalls, input.tools);
-  if (validToolCalls.length > 0) {
-    yield { type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] };
-  }
-  yield {
-    type: "finish",
-    data: { text: cleanedText, toolCalls: validToolCalls }
-  };
-};
-
 // src/provider-hf-transformers/common/HFT_Unload.ts
 init_HFT_Pipeline();
 function hasBrowserCacheStorage() {
@@ -1877,7 +1539,6 @@ var HFT_TASKS = {
   ImageEmbeddingTask: HFT_ImageEmbedding,
   ImageClassificationTask: HFT_ImageClassification,
   ObjectDetectionTask: HFT_ObjectDetection,
-  ToolCallingTask: HFT_ToolCalling,
   StructuredGenerationTask: HFT_StructuredGeneration,
   ModelSearchTask: HFT_ModelSearch
 };
@@ -1887,7 +1548,6 @@ var HFT_STREAM_TASKS = {
   TextSummaryTask: HFT_TextSummary_Stream,
   TextQuestionAnswerTask: HFT_TextQuestionAnswer_Stream,
   TextTranslationTask: HFT_TextTranslation_Stream,
-  ToolCallingTask: HFT_ToolCalling_Stream,
   StructuredGenerationTask: HFT_StructuredGeneration_Stream
 };
 var HFT_REACTIVE_TASKS = {
@@ -1898,11 +1558,34 @@ var HFT_REACTIVE_TASKS = {
 import {
   QueuedAiProvider
 } from "@workglow/ai";
+var GPU_DEVICES = new Set(["webgpu", "gpu", "metal"]);
+var HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION = 4;
+function hftIsAutomatedTestEnvironment() {
+  if (typeof process === "undefined") {
+    return false;
+  }
+  const e = process.env;
+  return e.VITEST === "true" || e.NODE_ENV === "test" || e.BUN_TEST === "1" || e.JEST_WORKER_ID !== undefined;
+}
+function hftDefaultCpuQueueConcurrency() {
+  return hftIsAutomatedTestEnvironment() ? 1 : HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION;
+}
+function resolveHftCpuQueueConcurrency(concurrency, defaultCpu) {
+  if (concurrency === undefined) {
+    return defaultCpu();
+  }
+  if (typeof concurrency === "number") {
+    return defaultCpu();
+  }
+  return concurrency.cpu ?? defaultCpu();
+}
+
 class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
   name = HF_TRANSFORMERS_ONNX;
   displayName = "Hugging Face Transformers (ONNX)";
   isLocal = true;
   supportsBrowser = true;
+  cpuStrategy;
   taskTypes = [
     "DownloadModelTask",
     "UnloadModelTask",
@@ -1924,12 +1607,22 @@ class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
     "ImageEmbeddingTask",
     "ImageClassificationTask",
     "ObjectDetectionTask",
-    "ToolCallingTask",
     "ModelSearchTask"
   ];
   constructor(tasks, streamTasks, reactiveTasks) {
     super(tasks, streamTasks, reactiveTasks);
   }
+  async afterRegister(options) {
+    await super.afterRegister(options);
+    this.cpuStrategy = this.createQueuedStrategy(HF_TRANSFORMERS_ONNX_CPU, resolveHftCpuQueueConcurrency(options.queue?.concurrency, hftDefaultCpuQueueConcurrency), options);
+  }
+  getStrategyForModel(model) {
+    const device = model.provider_config?.device;
+    if (device && GPU_DEVICES.has(device)) {
+      return this.queuedStrategy;
+    }
+    return this.cpuStrategy;
+  }
 }
 
 // src/provider-hf-transformers/registerHuggingFaceTransformersInline.ts
@@ -1978,7 +1671,6 @@ class HuggingFaceTransformersProvider extends AiProvider {
     "ImageEmbeddingTask",
     "ImageClassificationTask",
     "ObjectDetectionTask",
-    "ToolCallingTask",
     "ModelSearchTask"
   ];
   constructor(tasks, streamTasks, reactiveTasks) {
@@ -1989,7 +1681,9 @@ class HuggingFaceTransformersProvider extends AiProvider {
 // src/provider-hf-transformers/registerHuggingFaceTransformersWorker.ts
 init_HFT_Pipeline();
 async function registerHuggingFaceTransformersWorker() {
-  const { env } = await loadTransformersSDK();
+  const sdk = await loadTransformersSDK();
+  globalThis.__HFT__ = sdk;
+  const { env } = sdk;
   env.backends.onnx.wasm.proxy = true;
   const workerServer = globalServiceRegistry.get(WORKER_SERVER);
   new HuggingFaceTransformersProvider(HFT_TASKS, HFT_STREAM_TASKS, HFT_REACTIVE_TASKS).registerOnWorkerServer(workerServer);
@@ -2004,13 +1698,11 @@ export {
   removeCachedPipeline,
   registerHuggingFaceTransformersWorker,
   registerHuggingFaceTransformersInline,
-  parseToolCallsFromText,
   parseOnnxQuantizations,
   loadTransformersSDK,
   hasCachedPipeline,
   getPipelineCacheKey,
   getPipeline,
-  createToolCallMarkupFilter,
   clearPipelineCache,
   QuantizationDataType,
   PipelineUseCase,
@@ -2019,7 +1711,10 @@ export {
   HfTransformersOnnxModelRecordSchema,
   HfTransformersOnnxModelConfigSchema,
   HTF_CACHE_NAME,
-  HF_TRANSFORMERS_ONNX
+  HF_TRANSFORMERS_ONNX_GPU,
+  HF_TRANSFORMERS_ONNX_CPU,
+  HF_TRANSFORMERS_ONNX,
+  HFT_NULL_PROCESSOR_PREFIX
 };
 
-//# debugId=6F10F5E049CF8D0264756E2164756E21
+//# debugId=E4863FB6D65AEC2D64756E2164756E21