@workglow/ai-provider 0.0.89 → 0.0.91

package/dist/index.js

@@ -1,62 +1,117 @@
-// src/hf-transformers/common/HFT_Constants.ts
-var HF_TRANSFORMERS_ONNX = "HF_TRANSFORMERS_ONNX";
-var HTF_CACHE_NAME = "transformers-cache";
-var QuantizationDataType = {
-  auto: "auto",
-  fp32: "fp32",
-  fp16: "fp16",
-  q8: "q8",
-  int8: "int8",
-  uint8: "uint8",
-  q4: "q4",
-  bnb4: "bnb4",
-  q4f16: "q4f16"
-};
-var TextPipelineUseCase = {
-  "fill-mask": "fill-mask",
-  "token-classification": "token-classification",
-  "text-generation": "text-generation",
-  "text2text-generation": "text2text-generation",
-  "text-classification": "text-classification",
-  summarization: "summarization",
-  translation: "translation",
-  "feature-extraction": "feature-extraction",
-  "zero-shot-classification": "zero-shot-classification",
-  "question-answering": "question-answering"
-};
-var VisionPipelineUseCase = {
-  "background-removal": "background-removal",
-  "image-segmentation": "image-segmentation",
-  "depth-estimation": "depth-estimation",
-  "image-classification": "image-classification",
-  "image-to-image": "image-to-image",
-  "object-detection": "object-detection",
-  "image-feature-extraction": "image-feature-extraction"
-};
-var AudioPipelineUseCase = {
-  "audio-classification": "audio-classification",
-  "automatic-speech-recognition": "automatic-speech-recognition",
-  "text-to-speech": "text-to-speech"
-};
-var MultimodalPipelineUseCase = {
-  "document-question-answering": "document-question-answering",
-  "image-to-text": "image-to-text",
-  "zero-shot-audio-classification": "zero-shot-audio-classification",
-  "zero-shot-image-classification": "zero-shot-image-classification",
-  "zero-shot-object-detection": "zero-shot-object-detection"
-};
-var PipelineUseCase = {
-  ...TextPipelineUseCase,
-  ...VisionPipelineUseCase,
-  ...AudioPipelineUseCase,
-  ...MultimodalPipelineUseCase
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/hf-transformers/common/HFT_Constants.ts
+var HF_TRANSFORMERS_ONNX = "HF_TRANSFORMERS_ONNX", HTF_CACHE_NAME = "transformers-cache", QuantizationDataType, TextPipelineUseCase, VisionPipelineUseCase, AudioPipelineUseCase, MultimodalPipelineUseCase, PipelineUseCase;
+var init_HFT_Constants = __esm(() => {
+  QuantizationDataType = {
+    auto: "auto",
+    fp32: "fp32",
+    fp16: "fp16",
+    q8: "q8",
+    int8: "int8",
+    uint8: "uint8",
+    q4: "q4",
+    bnb4: "bnb4",
+    q4f16: "q4f16"
+  };
+  TextPipelineUseCase = {
+    "fill-mask": "fill-mask",
+    "token-classification": "token-classification",
+    "text-generation": "text-generation",
+    "text2text-generation": "text2text-generation",
+    "text-classification": "text-classification",
+    summarization: "summarization",
+    translation: "translation",
+    "feature-extraction": "feature-extraction",
+    "zero-shot-classification": "zero-shot-classification",
+    "question-answering": "question-answering"
+  };
+  VisionPipelineUseCase = {
+    "background-removal": "background-removal",
+    "image-segmentation": "image-segmentation",
+    "depth-estimation": "depth-estimation",
+    "image-classification": "image-classification",
+    "image-to-image": "image-to-image",
+    "object-detection": "object-detection",
+    "image-feature-extraction": "image-feature-extraction"
+  };
+  AudioPipelineUseCase = {
+    "audio-classification": "audio-classification",
+    "automatic-speech-recognition": "automatic-speech-recognition",
+    "text-to-speech": "text-to-speech"
+  };
+  MultimodalPipelineUseCase = {
+    "document-question-answering": "document-question-answering",
+    "image-to-text": "image-to-text",
+    "zero-shot-audio-classification": "zero-shot-audio-classification",
+    "zero-shot-image-classification": "zero-shot-image-classification",
+    "zero-shot-object-detection": "zero-shot-object-detection"
+  };
+  PipelineUseCase = {
+    ...TextPipelineUseCase,
+    ...VisionPipelineUseCase,
+    ...AudioPipelineUseCase,
+    ...MultimodalPipelineUseCase
+  };
+});
+
 // src/hf-transformers/common/HFT_JobRunFns.ts
-import {
-  pipeline,
-  TextStreamer
-} from "@sroussey/transformers";
-var pipelines = new Map;
+var exports_HFT_JobRunFns = {};
+__export(exports_HFT_JobRunFns, {
+  clearPipelineCache: () => clearPipelineCache,
+  HFT_Unload: () => HFT_Unload,
+  HFT_TextTranslation_Stream: () => HFT_TextTranslation_Stream,
+  HFT_TextTranslation: () => HFT_TextTranslation,
+  HFT_TextSummary_Stream: () => HFT_TextSummary_Stream,
+  HFT_TextSummary: () => HFT_TextSummary,
+  HFT_TextRewriter_Stream: () => HFT_TextRewriter_Stream,
+  HFT_TextRewriter: () => HFT_TextRewriter,
+  HFT_TextQuestionAnswer_Stream: () => HFT_TextQuestionAnswer_Stream,
+  HFT_TextQuestionAnswer: () => HFT_TextQuestionAnswer,
+  HFT_TextNamedEntityRecognition: () => HFT_TextNamedEntityRecognition,
+  HFT_TextLanguageDetection: () => HFT_TextLanguageDetection,
+  HFT_TextGeneration_Stream: () => HFT_TextGeneration_Stream,
+  HFT_TextGeneration: () => HFT_TextGeneration,
+  HFT_TextFillMask: () => HFT_TextFillMask,
+  HFT_TextEmbedding: () => HFT_TextEmbedding,
+  HFT_TextClassification: () => HFT_TextClassification,
+  HFT_TASKS: () => HFT_TASKS,
+  HFT_STREAM_TASKS: () => HFT_STREAM_TASKS,
+  HFT_ObjectDetection: () => HFT_ObjectDetection,
+  HFT_ImageToText: () => HFT_ImageToText,
+  HFT_ImageSegmentation: () => HFT_ImageSegmentation,
+  HFT_ImageEmbedding: () => HFT_ImageEmbedding,
+  HFT_ImageClassification: () => HFT_ImageClassification,
+  HFT_Download: () => HFT_Download,
+  HFT_BackgroundRemoval: () => HFT_BackgroundRemoval
+});
+async function loadTransformersSDK() {
+  if (!_transformersSdk) {
+    try {
+      _transformersSdk = await import("@sroussey/transformers");
+    } catch {
+      throw new Error("@sroussey/transformers is required for HuggingFace Transformers tasks. Install it with: bun add @sroussey/transformers");
+    }
+  }
+  return _transformersSdk;
+}
 function clearPipelineCache() {
   pipelines.clear();
 }
@@ -65,7 +120,87 @@ function getPipelineCacheKey(model) {
   const device = model.provider_config.device || "";
   return `${model.provider_config.model_path}:${model.provider_config.pipeline}:${dtype}:${device}`;
 }
-var getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10) => {
+function imageToBase64(image) {
+  return image.toBase64?.() || "";
+}
+function createTextStreamer(tokenizer, updateProgress, signal) {
+  const { TextStreamer } = _transformersSdk;
+  let count = 0;
+  return new TextStreamer(tokenizer, {
+    skip_prompt: true,
+    decode_kwargs: { skip_special_tokens: true },
+    callback_function: (text) => {
+      count++;
+      const result = 100 * (1 - Math.exp(-0.05 * count));
+      const progress = Math.round(Math.min(result, 100));
+      updateProgress(progress, "Generating", { text, progress });
+    },
+    ...signal ? { abort_signal: signal } : {}
+  });
+}
+function createStreamEventQueue() {
+  const buffer = [];
+  let resolve = null;
+  let finished = false;
+  let err = null;
+  const push = (event) => {
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: event, done: false });
+    } else {
+      buffer.push(event);
+    }
+  };
+  const done = () => {
+    finished = true;
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: undefined, done: true });
+    }
+  };
+  const error = (e) => {
+    err = e;
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: undefined, done: true });
+    }
+  };
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (err)
+            return Promise.reject(err);
+          if (buffer.length > 0) {
+            return Promise.resolve({ value: buffer.shift(), done: false });
+          }
+          if (finished) {
+            return Promise.resolve({ value: undefined, done: true });
+          }
+          return new Promise((r) => {
+            resolve = r;
+          });
+        }
+      };
+    }
+  };
+  return { push, done, error, iterable };
+}
+function createStreamingTextStreamer(tokenizer, queue, signal) {
+  const { TextStreamer } = _transformersSdk;
+  return new TextStreamer(tokenizer, {
+    skip_prompt: true,
+    decode_kwargs: { skip_special_tokens: true },
+    callback_function: (text) => {
+      queue.push({ type: "text-delta", textDelta: text });
+    },
+    ...signal ? { abort_signal: signal } : {}
+  });
+}
+var _transformersSdk, pipelines, getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10) => {
   const cacheKey = getPipelineCacheKey(model);
   if (pipelines.has(cacheKey)) {
     return pipelines.get(cacheKey);
@@ -82,8 +217,8 @@ var getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10)
   const estimatedTinyFiles = 3;
   const estimatedMediumFiles = 1;
   const estimatedTinySize = 1024;
-  const estimatedMediumSize = 20 * 1024 * 1024;
-  const estimatedLargeSize = 1024 * 1024 * 1024;
+  const estimatedMediumSize = 20971520;
+  const estimatedLargeSize = 1073741824;
   const baseEstimate = estimatedTinyFiles * estimatedTinySize + estimatedMediumFiles * estimatedMediumSize;
   const sendProgress = (overallProgress, file, fileProgressValue, isFirst, isLast) => {
     const now = Date.now();
@@ -124,7 +259,7 @@ var getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10)
     }
   };
   let hasSeenSubstantialFile = false;
-  const substantialFileThreshold = 1024 * 1024;
+  const substantialFileThreshold = 1048576;
   const abortSignal = options.abort_signal;
   const progressCallback = (status) => {
     if (abortSignal?.aborted) {
@@ -149,8 +284,8 @@ var getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10)
       }
       let actualLoadedSize = 0;
       let actualTotalSize = 0;
-      const tinyThreshold = 100 * 1024;
-      const mediumThreshold = 100 * 1024 * 1024;
+      const tinyThreshold = 102400;
+      const mediumThreshold = 104857600;
       let seenTinyCount = 0;
       let seenMediumCount = 0;
       let seenLargeCount = 0;
@@ -200,8 +335,8 @@ var getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10)
         fileProgress.set(file, 100);
         let actualLoadedSize = 0;
         let actualTotalSize = 0;
-        const tinyThreshold = 100 * 1024;
-        const mediumThreshold = 100 * 1024 * 1024;
+        const tinyThreshold = 102400;
+        const mediumThreshold = 104857600;
         let seenTinyCount = 0;
         let seenMediumCount = 0;
         let seenLargeCount = 0;
@@ -262,6 +397,7 @@ var getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10)
       }
     }
   });
+  const { pipeline } = await loadTransformersSDK();
   const pipelinePromise = pipeline(pipelineType, model.provider_config.model_path, pipelineOptions);
   try {
     const result = await (abortSignal ? Promise.race([pipelinePromise, abortPromise]) : pipelinePromise);
@@ -276,14 +412,12 @@ var getPipeline = async (model, onProgress, options = {}, progressScaleMax = 10)
     }
     throw error;
   }
-};
-var HFT_Download = async (input, model, onProgress, signal) => {
+}, HFT_Download = async (input, model, onProgress, signal) => {
   await getPipeline(model, onProgress, { abort_signal: signal }, 100);
   return {
     model: input.model
   };
-};
-var HFT_Unload = async (input, model, onProgress, signal) => {
+}, HFT_Unload = async (input, model, onProgress, signal) => {
   const cacheKey = getPipelineCacheKey(model);
   if (pipelines.has(cacheKey)) {
     pipelines.delete(cacheKey);
@@ -295,8 +429,7 @@ var HFT_Unload = async (input, model, onProgress, signal) => {
   return {
     model: input.model
   };
-};
-var deleteModelCache = async (model_path) => {
+}, deleteModelCache = async (model_path) => {
   const cache = await caches.open(HTF_CACHE_NAME);
   const keys = await cache.keys();
   const prefix = `/${model_path}/`;
@@ -323,8 +456,7 @@ var deleteModelCache = async (model_path) => {
       console.error(`Failed to delete cache entry: ${request.url}`, error);
     }
   }
-};
-var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
+}, HFT_TextEmbedding = async (input, model, onProgress, signal) => {
   const generateEmbedding = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -351,8 +483,7 @@ var HFT_TextEmbedding = async (input, model, onProgress, signal) => {
     throw new Error(`HuggingFace Embedding vector length does not match model dimensions v${hfVector.size} != m${embeddingDim}`);
   }
   return { vector: hfVector.data };
-};
-var HFT_TextClassification = async (input, model, onProgress, signal) => {
+}, HFT_TextClassification = async (input, model, onProgress, signal) => {
   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");
@@ -389,8 +520,7 @@ var HFT_TextClassification = async (input, model, onProgress, signal) => {
       score: category.score
     }))
   };
-};
-var HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
+}, HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
   const TextClassification = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -412,8 +542,7 @@ var HFT_TextLanguageDetection = async (input, model, onProgress, signal) => {
       score: category.score
     }))
   };
-};
-var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
+}, HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) => {
   const textNamedEntityRecognition = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -434,8 +563,7 @@ var HFT_TextNamedEntityRecognition = async (input, model, onProgress, signal) =>
       word: entity.word
     }))
   };
-};
-var HFT_TextFillMask = async (input, model, onProgress, signal) => {
+}, HFT_TextFillMask = async (input, model, onProgress, signal) => {
   const unmasker = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -453,8 +581,7 @@ var HFT_TextFillMask = async (input, model, onProgress, signal) => {
       sequence: prediction.sequence
     }))
   };
-};
-var HFT_TextGeneration = async (input, model, onProgress, signal) => {
+}, HFT_TextGeneration = async (input, model, onProgress, signal) => {
   const generateText = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -473,8 +600,7 @@ var HFT_TextGeneration = async (input, model, onProgress, signal) => {
   return {
     text
   };
-};
-var HFT_TextTranslation = async (input, model, onProgress, signal) => {
+}, HFT_TextTranslation = async (input, model, onProgress, signal) => {
   const translate = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -490,8 +616,7 @@ var HFT_TextTranslation = async (input, model, onProgress, signal) => {
     text: translatedText,
     target_lang: input.target_lang
   };
-};
-var HFT_TextRewriter = async (input, model, onProgress, signal) => {
+}, HFT_TextRewriter = async (input, model, onProgress, signal) => {
   const generateText = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -515,8 +640,7 @@ var HFT_TextRewriter = async (input, model, onProgress, signal) => {
   return {
     text
   };
-};
-var HFT_TextSummary = async (input, model, onProgress, signal) => {
+}, HFT_TextSummary = async (input, model, onProgress, signal) => {
   const generateSummary = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -534,8 +658,7 @@ var HFT_TextSummary = async (input, model, onProgress, signal) => {
   return {
     text: summaryText
   };
-};
-var HFT_TextQuestionAnswer = async (input, model, onProgress, signal) => {
+}, HFT_TextQuestionAnswer = async (input, model, onProgress, signal) => {
   const generateAnswer = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -553,8 +676,7 @@ var HFT_TextQuestionAnswer = async (input, model, onProgress, signal) => {
   return {
     text: answerText
   };
-};
-var HFT_ImageSegmentation = async (input, model, onProgress, signal) => {
+}, HFT_ImageSegmentation = async (input, model, onProgress, signal) => {
   const segmenter = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -572,8 +694,7 @@ var HFT_ImageSegmentation = async (input, model, onProgress, signal) => {
   return {
     masks: processedMasks
   };
-};
-var HFT_ImageToText = async (input, model, onProgress, signal) => {
+}, HFT_ImageToText = async (input, model, onProgress, signal) => {
   const captioner = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -585,8 +706,7 @@ var HFT_ImageToText = async (input, model, onProgress, signal) => {
   return {
     text: text || ""
   };
-};
-var HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
+}, HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
   const remover = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -597,8 +717,7 @@ var HFT_BackgroundRemoval = async (input, model, onProgress, signal) => {
   return {
     image: imageToBase64(resultImage)
   };
-};
-var HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
+}, HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
   const embedder = await getPipeline(model, onProgress, {
     abort_signal: signal
   });
@@ -606,8 +725,7 @@ var HFT_ImageEmbedding = async (input, model, onProgress, signal) => {
   return {
     vector: result.data
   };
-};
-var HFT_ImageClassification = async (input, model, onProgress, signal) => {
+}, HFT_ImageClassification = async (input, model, onProgress, signal) => {
   if (model?.provider_config?.pipeline === "zero-shot-image-classification") {
     if (!input.categories || !Array.isArray(input.categories) || input.categories.length === 0) {
       console.warn("Zero-shot image classification requires categories", input);
@@ -639,8 +757,7 @@ var HFT_ImageClassification = async (input, model, onProgress, signal) => {
       score: r.score
     }))
   };
-};
-var HFT_ObjectDetection = async (input, model, onProgress, signal) => {
+}, HFT_ObjectDetection = async (input, model, onProgress, signal) => {
   if (model?.provider_config?.pipeline === "zero-shot-object-detection") {
     if (!input.labels || !Array.isArray(input.labels) || input.labels.length === 0) {
       throw new Error("Zero-shot object detection requires labels");
@@ -675,26 +792,285 @@ var HFT_ObjectDetection = async (input, model, onProgress, signal) => {
       box: d.box
     }))
   };
-};
-function imageToBase64(image) {
-  return image.toBase64?.() || "";
-}
-function createTextStreamer(tokenizer, updateProgress, signal) {
-  let count = 0;
-  return new TextStreamer(tokenizer, {
-    skip_prompt: true,
-    decode_kwargs: { skip_special_tokens: true },
-    callback_function: (text) => {
-      count++;
-      const result = 100 * (1 - Math.exp(-0.05 * count));
-      const progress = Math.round(Math.min(result, 100));
-      updateProgress(progress, "Generating", { text, progress });
-    },
+}, HFT_TextGeneration_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, signal);
+  const pipelinePromise = generateText(input.prompt, {
+    streamer,
     ...signal ? { abort_signal: signal } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+}, HFT_TextRewriter_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {
+    abort_signal: signal
   });
-}
-// src/hf-transformers/common/HFT_ModelSchema.ts
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, queue);
+  const promptedText = (input.prompt ? input.prompt + `
+` : "") + input.text;
+  const pipelinePromise = generateText(promptedText, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+}, HFT_TextSummary_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateSummary = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateSummary.tokenizer, queue);
+  const pipelinePromise = generateSummary(input.text, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: {} };
+}, HFT_TextQuestionAnswer_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateAnswer = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateAnswer.tokenizer, queue);
+  let pipelineResult;
+  const pipelinePromise = generateAnswer(input.question, input.context, {
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).then((result) => {
+    pipelineResult = result;
+    queue.done();
+  }, (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  let answerText = "";
+  if (pipelineResult !== undefined) {
+    if (Array.isArray(pipelineResult)) {
+      answerText = pipelineResult[0]?.answer ?? "";
+    } else {
+      answerText = pipelineResult?.answer ?? "";
+    }
+  }
+  yield { type: "finish", data: { text: answerText } };
+}, HFT_TextTranslation_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const translate = await getPipeline(model, noopProgress, {
+    abort_signal: signal
+  });
+  const queue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(translate.tokenizer, queue);
+  const pipelinePromise = translate(input.text, {
+    src_lang: input.source_lang,
+    tgt_lang: input.target_lang,
+    streamer,
+    ...signal ? { abort_signal: signal } : {}
+  }).then(() => queue.done(), (err) => queue.error(err));
+  yield* queue.iterable;
+  await pipelinePromise;
+  yield { type: "finish", data: { target_lang: input.target_lang } };
+}, HFT_TASKS, HFT_STREAM_TASKS;
+var init_HFT_JobRunFns = __esm(() => {
+  init_HFT_Constants();
+  pipelines = new Map;
+  HFT_TASKS = {
+    DownloadModelTask: HFT_Download,
+    UnloadModelTask: HFT_Unload,
+    TextEmbeddingTask: HFT_TextEmbedding,
+    TextGenerationTask: HFT_TextGeneration,
+    TextQuestionAnswerTask: HFT_TextQuestionAnswer,
+    TextLanguageDetectionTask: HFT_TextLanguageDetection,
+    TextClassificationTask: HFT_TextClassification,
+    TextFillMaskTask: HFT_TextFillMask,
+    TextNamedEntityRecognitionTask: HFT_TextNamedEntityRecognition,
+    TextRewriterTask: HFT_TextRewriter,
+    TextSummaryTask: HFT_TextSummary,
+    TextTranslationTask: HFT_TextTranslation,
+    ImageSegmentationTask: HFT_ImageSegmentation,
+    ImageToTextTask: HFT_ImageToText,
+    BackgroundRemovalTask: HFT_BackgroundRemoval,
+    ImageEmbeddingTask: HFT_ImageEmbedding,
+    ImageClassificationTask: HFT_ImageClassification,
+    ObjectDetectionTask: HFT_ObjectDetection
+  };
+  HFT_STREAM_TASKS = {
+    TextGenerationTask: HFT_TextGeneration_Stream,
+    TextRewriterTask: HFT_TextRewriter_Stream,
+    TextSummaryTask: HFT_TextSummary_Stream,
+    TextQuestionAnswerTask: HFT_TextQuestionAnswer_Stream,
+    TextTranslationTask: HFT_TextTranslation_Stream
+  };
+});
+
+// src/anthropic/common/Anthropic_Constants.ts
+var ANTHROPIC = "ANTHROPIC";
+// src/google-gemini/common/Gemini_Constants.ts
+var GOOGLE_GEMINI = "GOOGLE_GEMINI";
+
+// src/index.ts
+init_HFT_Constants();
+
+// src/provider-ollama/common/Ollama_Constants.ts
+var OLLAMA = "OLLAMA";
+var OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434";
+// src/provider-openai/common/OpenAI_Constants.ts
+var OPENAI = "OPENAI";
+// src/tf-mediapipe/common/TFMP_Constants.ts
+var TENSORFLOW_MEDIAPIPE = "TENSORFLOW_MEDIAPIPE";
+var TextPipelineTask = {
+  "text-embedder": "text-embedder",
+  "text-classifier": "text-classifier",
+  "text-language-detector": "text-language-detector",
+  "genai-text": "genai-text",
+  "audio-classifier": "audio-classifier",
+  "audio-embedder": "audio-embedder",
+  "vision-face-detector": "vision-face-detector",
+  "vision-face-landmarker": "vision-face-landmarker",
+  "vision-face-stylizer": "vision-face-stylizer",
+  "vision-gesture-recognizer": "vision-gesture-recognizer",
+  "vision-hand-landmarker": "vision-hand-landmarker",
+  "vision-holistic-landmarker": "vision-holistic-landmarker",
+  "vision-image-classifier": "vision-image-classifier",
+  "vision-image-embedder": "vision-image-embedder",
+  "vision-image-segmenter": "vision-image-segmenter",
+  "vision-image-interactive-segmenter": "vision-image-interactive-segmenter",
+  "vision-object-detector": "vision-object-detector",
+  "vision-pose-landmarker": "vision-pose-landmarker"
+};
+// src/anthropic/common/Anthropic_ModelSchema.ts
 import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai";
+var AnthropicModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: ANTHROPIC,
+      description: "Discriminator: Anthropic cloud provider."
+    },
+    provider_config: {
+      type: "object",
+      description: "Anthropic-specific configuration.",
+      properties: {
+        model_name: {
+          type: "string",
+          description: "The Anthropic model identifier (e.g., 'claude-sonnet-4-20250514', 'claude-3-5-haiku-20241022')."
+        },
+        api_key: {
+          type: "string",
+          description: "Anthropic API key. Falls back to ANTHROPIC_API_KEY environment variable if not set.",
+          "x-ui-hidden": true
+        },
+        base_url: {
+          type: "string",
+          description: "Base URL for the Anthropic API (optional)."
+        },
+        max_tokens: {
+          type: "integer",
+          description: "Default max tokens for responses. Anthropic requires this parameter.",
+          default: 1024,
+          minimum: 1
+        }
+      },
+      required: ["model_name"],
+      additionalProperties: false
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var AnthropicModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...AnthropicModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...AnthropicModelSchema.required],
+  additionalProperties: false
+};
+var AnthropicModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...AnthropicModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...AnthropicModelSchema.required],
+  additionalProperties: false
+};
+// src/google-gemini/common/Gemini_ModelSchema.ts
+import { ModelConfigSchema as ModelConfigSchema2, ModelRecordSchema as ModelRecordSchema2 } from "@workglow/ai";
+var GeminiModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: GOOGLE_GEMINI,
+      description: "Discriminator: Google Gemini cloud provider."
+    },
+    provider_config: {
+      type: "object",
+      description: "Google Gemini-specific configuration.",
+      properties: {
+        model_name: {
+          type: "string",
+          description: "The Gemini model identifier (e.g., 'gemini-2.0-flash', 'text-embedding-004')."
+        },
+        api_key: {
+          type: "string",
+          description: "Google AI API key. Falls back to default API key if not set."
+        },
+        embedding_task_type: {
+          oneOf: [
+            { type: "null" },
+            {
+              type: "string",
+              enum: [
+                "RETRIEVAL_QUERY",
+                "RETRIEVAL_DOCUMENT",
+                "SEMANTIC_SIMILARITY",
+                "CLASSIFICATION",
+                "CLUSTERING"
+              ]
+            }
+          ],
+          description: "Task type hint for embedding models.",
+          default: null
+        }
+      },
+      required: ["model_name"],
+      additionalProperties: false
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var GeminiModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema2.properties,
+    ...GeminiModelSchema.properties
+  },
+  required: [...ModelRecordSchema2.required, ...GeminiModelSchema.required],
+  additionalProperties: false
+};
+var GeminiModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema2.properties,
+    ...GeminiModelSchema.properties
+  },
+  required: [...ModelConfigSchema2.required, ...GeminiModelSchema.required],
+  additionalProperties: false
+};
+// src/hf-transformers/common/HFT_ModelSchema.ts
+init_HFT_Constants();
+import { ModelConfigSchema as ModelConfigSchema3, ModelRecordSchema as ModelRecordSchema3 } from "@workglow/ai";
 var HfTransformersOnnxModelSchema = {
   type: "object",
   properties: {
@@ -791,638 +1167,127 @@ var HfTransformersOnnxModelSchema = {
 var HfTransformersOnnxModelRecordSchema = {
   type: "object",
   properties: {
-    ...ModelRecordSchema.properties,
+    ...ModelRecordSchema3.properties,
     ...HfTransformersOnnxModelSchema.properties
   },
-  required: [...ModelRecordSchema.required, ...HfTransformersOnnxModelSchema.required],
+  required: [...ModelRecordSchema3.required, ...HfTransformersOnnxModelSchema.required],
   additionalProperties: false
 };
 var HfTransformersOnnxModelConfigSchema = {
   type: "object",
   properties: {
-    ...ModelConfigSchema.properties,
+    ...ModelConfigSchema3.properties,
     ...HfTransformersOnnxModelSchema.properties
   },
-  required: [...ModelConfigSchema.required, ...HfTransformersOnnxModelSchema.required],
+  required: [...ModelConfigSchema3.required, ...HfTransformersOnnxModelSchema.required],
   additionalProperties: false
 };
-// src/hf-transformers/registry/HFT_Client_RegisterJobFns.ts
-import { AiJob, getAiProviderRegistry } from "@workglow/ai";
-import { ConcurrencyLimiter, JobQueueClient, JobQueueServer } from "@workglow/job-queue";
-import { InMemoryQueueStorage } from "@workglow/storage";
-import { getTaskQueueRegistry } from "@workglow/task-graph";
-import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util";
-async function register_HFT_ClientJobFns(worker, client) {
-  const workerManager = globalServiceRegistry.get(WORKER_MANAGER);
-  workerManager.registerWorker(HF_TRANSFORMERS_ONNX, worker);
-  const ProviderRegistry = getAiProviderRegistry();
-  const names = [
-    "DownloadModelTask",
-    "UnloadModelTask",
-    "TextEmbeddingTask",
-    "TextLanguageDetectionTask",
-    "TextClassificationTask",
-    "TextFillMaskTask",
-    "TextNamedEntityRecognitionTask",
-    "TextGenerationTask",
-    "TextTranslationTask",
-    "TextRewriterTask",
-    "TextSummaryTask",
-    "TextQuestionAnswerTask",
-    "ImageSegmentationTask",
-    "ImageToTextTask",
-    "BackgroundRemovalTask",
-    "ImageEmbeddingTask",
-    "ImageClassificationTask",
-    "ObjectDetectionTask"
-  ];
-  for (const name of names) {
-    ProviderRegistry.registerAsWorkerRunFn(HF_TRANSFORMERS_ONNX, name);
-  }
-  if (!client) {
-    const storage = new InMemoryQueueStorage(HF_TRANSFORMERS_ONNX);
-    const server = new JobQueueServer(AiJob, {
-      storage,
-      queueName: HF_TRANSFORMERS_ONNX,
-      limiter: new ConcurrencyLimiter(1, 100)
-    });
-    client = new JobQueueClient({
-      storage,
-      queueName: HF_TRANSFORMERS_ONNX
-    });
-    client.attach(server);
-    getTaskQueueRegistry().registerQueue({ server, client, storage });
-  }
-}
-// src/hf-transformers/registry/HFT_Inline_RegisterJobFns.ts
-import { env } from "@sroussey/transformers";
-import { AiJob as AiJob2, getAiProviderRegistry as getAiProviderRegistry2 } from "@workglow/ai";
-import { ConcurrencyLimiter as ConcurrencyLimiter2, JobQueueClient as JobQueueClient2, JobQueueServer as JobQueueServer2 } from "@workglow/job-queue";
-import { InMemoryQueueStorage as InMemoryQueueStorage2 } from "@workglow/storage";
-import { getTaskQueueRegistry as getTaskQueueRegistry2 } from "@workglow/task-graph";
-async function register_HFT_InlineJobFns(client) {
-  env.backends.onnx.wasm.proxy = true;
-  const ProviderRegistry = getAiProviderRegistry2();
-  const fns = {
-    ["DownloadModelTask"]: HFT_Download,
-    ["UnloadModelTask"]: HFT_Unload,
-    ["TextEmbeddingTask"]: HFT_TextEmbedding,
-    ["TextGenerationTask"]: HFT_TextGeneration,
-    ["TextQuestionAnswerTask"]: HFT_TextQuestionAnswer,
-    ["TextLanguageDetectionTask"]: HFT_TextLanguageDetection,
-    ["TextClassificationTask"]: HFT_TextClassification,
-    ["TextFillMaskTask"]: HFT_TextFillMask,
-    ["TextNamedEntityRecognitionTask"]: HFT_TextNamedEntityRecognition,
-    ["TextRewriterTask"]: HFT_TextRewriter,
-    ["TextSummaryTask"]: HFT_TextSummary,
-    ["TextTranslationTask"]: HFT_TextTranslation,
-    ["ImageSegmentationTask"]: HFT_ImageSegmentation,
-    ["ImageToTextTask"]: HFT_ImageToText,
-    ["BackgroundRemovalTask"]: HFT_BackgroundRemoval,
-    ["ImageEmbeddingTask"]: HFT_ImageEmbedding,
-    ["ImageClassificationTask"]: HFT_ImageClassification,
-    ["ObjectDetectionTask"]: HFT_ObjectDetection
-  };
-  for (const [jobName, fn] of Object.entries(fns)) {
-    ProviderRegistry.registerRunFn(HF_TRANSFORMERS_ONNX, jobName, fn);
-  }
-  if (!client) {
-    const storage = new InMemoryQueueStorage2(HF_TRANSFORMERS_ONNX);
-    await storage.setupDatabase();
-    const server = new JobQueueServer2(AiJob2, {
-      storage,
-      queueName: HF_TRANSFORMERS_ONNX,
-      limiter: new ConcurrencyLimiter2(1, 100)
-    });
-    client = new JobQueueClient2({
-      storage,
-      queueName: HF_TRANSFORMERS_ONNX
-    });
-    client.attach(server);
-    getTaskQueueRegistry2().registerQueue({ server, client, storage });
-    await server.start();
-  }
-}
-// src/hf-transformers/registry/HFT_Worker_RegisterJobFns.ts
-import {
-  createServiceToken,
-  globalServiceRegistry as globalServiceRegistry2,
-  parentPort,
-  WORKER_SERVER
-} from "@workglow/util";
-var HFT_WORKER_JOBRUN = createServiceToken("worker.ai-provider.hft");
-var HFT_WORKER_JOBRUN_REGISTER = globalServiceRegistry2.register(HFT_WORKER_JOBRUN, () => {
-  const workerServer = globalServiceRegistry2.get(WORKER_SERVER);
-  workerServer.registerFunction("DownloadModelTask", HFT_Download);
-  workerServer.registerFunction("UnloadModelTask", HFT_Unload);
-  workerServer.registerFunction("TextEmbeddingTask", HFT_TextEmbedding);
-  workerServer.registerFunction("TextGenerationTask", HFT_TextGeneration);
-  workerServer.registerFunction("TextLanguageDetectionTask", HFT_TextLanguageDetection);
-  workerServer.registerFunction("TextClassificationTask", HFT_TextClassification);
-  workerServer.registerFunction("TextFillMaskTask", HFT_TextFillMask);
-  workerServer.registerFunction("TextNamedEntityRecognitionTask", HFT_TextNamedEntityRecognition);
-  workerServer.registerFunction("TextTranslationTask", HFT_TextTranslation);
-  workerServer.registerFunction("TextRewriterTask", HFT_TextRewriter);
-  workerServer.registerFunction("TextSummaryTask", HFT_TextSummary);
-  workerServer.registerFunction("TextQuestionAnswerTask", HFT_TextQuestionAnswer);
-  workerServer.registerFunction("ImageSegmentationTask", HFT_ImageSegmentation);
-  workerServer.registerFunction("ImageToTextTask", HFT_ImageToText);
-  workerServer.registerFunction("BackgroundRemovalTask", HFT_BackgroundRemoval);
-  workerServer.registerFunction("ImageEmbeddingTask", HFT_ImageEmbedding);
-  workerServer.registerFunction("ImageClassificationTask", HFT_ImageClassification);
-  workerServer.registerFunction("ObjectDetectionTask", HFT_ObjectDetection);
-  parentPort.postMessage({ type: "ready" });
-  console.log("HFT_WORKER_JOBRUN registered");
-  return workerServer;
-}, true);
-// src/tf-mediapipe/common/TFMP_Constants.ts
-var TENSORFLOW_MEDIAPIPE = "TENSORFLOW_MEDIAPIPE";
-var TextPipelineTask = {
-  "text-embedder": "text-embedder",
-  "text-classifier": "text-classifier",
-  "text-language-detector": "text-language-detector",
-  "genai-text": "genai-text",
-  "audio-classifier": "audio-classifier",
-  "audio-embedder": "audio-embedder",
-  "vision-face-detector": "vision-face-detector",
-  "vision-face-landmarker": "vision-face-landmarker",
-  "vision-face-stylizer": "vision-face-stylizer",
-  "vision-gesture-recognizer": "vision-gesture-recognizer",
-  "vision-hand-landmarker": "vision-hand-landmarker",
-  "vision-holistic-landmarker": "vision-holistic-landmarker",
-  "vision-image-classifier": "vision-image-classifier",
-  "vision-image-embedder": "vision-image-embedder",
-  "vision-image-segmenter": "vision-image-segmenter",
-  "vision-image-interactive-segmenter": "vision-image-interactive-segmenter",
-  "vision-object-detector": "vision-object-detector",
-  "vision-pose-landmarker": "vision-pose-landmarker"
-};
-// src/tf-mediapipe/common/TFMP_JobRunFns.ts
-import {
-  FilesetResolver,
-  LanguageDetector,
-  TextClassifier,
-  TextEmbedder
-} from "@mediapipe/tasks-text";
-import {
-  FaceDetector,
-  FaceLandmarker,
-  GestureRecognizer,
-  HandLandmarker,
-  ImageClassifier,
-  ImageEmbedder,
-  ImageSegmenter,
-  ObjectDetector,
-  PoseLandmarker
-} from "@mediapipe/tasks-vision";
-import { PermanentJobError } from "@workglow/job-queue";
-var wasm_tasks = new Map;
-var wasm_reference_counts = new Map;
-var getWasmTask = async (model, onProgress, signal) => {
-  const task_engine = model.provider_config.task_engine;
-  if (wasm_tasks.has(task_engine)) {
-    return wasm_tasks.get(task_engine);
-  }
-  if (signal.aborted) {
-    throw new PermanentJobError("Aborted job");
-  }
-  onProgress(0.1, "Loading WASM task");
-  let wasmFileset;
-  switch (task_engine) {
-    case "text":
-      wasmFileset = await FilesetResolver.forTextTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-text@latest/wasm");
-      break;
-    case "audio":
-      wasmFileset = await FilesetResolver.forAudioTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-audio@latest/wasm");
-      break;
-    case "vision":
-      wasmFileset = await FilesetResolver.forVisionTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm");
-      break;
-    case "genai":
-      wasmFileset = await FilesetResolver.forGenAiTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm");
-      break;
-    default:
-      throw new PermanentJobError("Invalid task engine");
-  }
-  wasm_tasks.set(task_engine, wasmFileset);
-  return wasmFileset;
-};
-var modelTaskCache = new Map;
-var optionsMatch = (opts1, opts2) => {
-  const keys1 = Object.keys(opts1).sort();
-  const keys2 = Object.keys(opts2).sort();
-  if (keys1.length !== keys2.length)
-    return false;
-  return keys1.every((key) => {
-    const val1 = opts1[key];
-    const val2 = opts2[key];
-    if (Array.isArray(val1) && Array.isArray(val2)) {
-      return JSON.stringify(val1) === JSON.stringify(val2);
-    }
-    return val1 === val2;
-  });
-};
-var getModelTask = async (model, options, onProgress, signal, TaskType) => {
-  const model_path = model.provider_config.model_path;
-  const task_engine = model.provider_config.task_engine;
-  const cachedTasks = modelTaskCache.get(model_path);
-  if (cachedTasks) {
-    const matchedTask = cachedTasks.find((cached) => optionsMatch(cached.options, options));
-    if (matchedTask) {
-      return matchedTask.task;
-    }
-  }
-  const wasmFileset = await getWasmTask(model, onProgress, signal);
-  onProgress(0.2, "Creating model task");
-  const task = await TaskType.createFromOptions(wasmFileset, {
-    baseOptions: {
-      modelAssetPath: model_path
+// src/provider-ollama/common/Ollama_ModelSchema.ts
+import { ModelConfigSchema as ModelConfigSchema4, ModelRecordSchema as ModelRecordSchema4 } from "@workglow/ai";
+var OllamaModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: OLLAMA,
+      description: "Discriminator: Ollama local LLM server."
     },
-    ...options
-  });
-  const cachedTask = { task, options, task_engine };
-  if (!modelTaskCache.has(model_path)) {
-    modelTaskCache.set(model_path, []);
-  }
-  modelTaskCache.get(model_path).push(cachedTask);
-  wasm_reference_counts.set(task_engine, (wasm_reference_counts.get(task_engine) || 0) + 1);
-  return task;
-};
-var TFMP_Download = async (input, model, onProgress, signal) => {
-  let task;
-  switch (model?.provider_config.pipeline) {
-    case "text-embedder":
-      task = await getModelTask(model, {}, onProgress, signal, TextEmbedder);
-      break;
-    case "text-classifier":
-      task = await getModelTask(model, {}, onProgress, signal, TextClassifier);
-      break;
-    case "text-language-detector":
-      task = await getModelTask(model, {}, onProgress, signal, LanguageDetector);
-      break;
-    case "vision-image-classifier":
-      task = await getModelTask(model, {}, onProgress, signal, ImageClassifier);
-      break;
-    case "vision-image-embedder":
-      task = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
-      break;
-    case "vision-image-segmenter":
-      task = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
-      break;
-    case "vision-object-detector":
-      task = await getModelTask(model, {}, onProgress, signal, ObjectDetector);
-      break;
-    case "vision-face-detector":
-      task = await getModelTask(model, {}, onProgress, signal, FaceDetector);
-      break;
-    case "vision-face-landmarker":
-      task = await getModelTask(model, {}, onProgress, signal, FaceLandmarker);
-      break;
-    case "vision-gesture-recognizer":
-      task = await getModelTask(model, {}, onProgress, signal, GestureRecognizer);
-      break;
-    case "vision-hand-landmarker":
-      task = await getModelTask(model, {}, onProgress, signal, HandLandmarker);
-      break;
-    case "vision-pose-landmarker":
-      task = await getModelTask(model, {}, onProgress, signal, PoseLandmarker);
-      break;
-    default:
-      throw new PermanentJobError(`Invalid pipeline: ${model?.provider_config.pipeline}. Supported pipelines: text-embedder, text-classifier, text-language-detector, vision-image-classifier, vision-image-embedder, vision-image-segmenter, vision-object-detector, vision-face-detector, vision-face-landmarker, vision-gesture-recognizer, vision-hand-landmarker, vision-pose-landmarker`);
-  }
-  onProgress(0.9, "Pipeline loaded");
-  task.close();
-  const task_engine = model?.provider_config.task_engine;
-  wasm_reference_counts.set(task_engine, wasm_reference_counts.get(task_engine) - 1);
-  return {
-    model: input.model
-  };
-};
-var TFMP_TextEmbedding = async (input, model, onProgress, signal) => {
-  const textEmbedder = await getModelTask(model, {}, onProgress, signal, TextEmbedder);
-  if (Array.isArray(input.text)) {
-    const embeddings = input.text.map((text) => {
-      const result2 = textEmbedder.embed(text);
-      if (!result2.embeddings?.[0]?.floatEmbedding) {
-        throw new PermanentJobError("Failed to generate embedding: Empty result");
-      }
-      return Float32Array.from(result2.embeddings[0].floatEmbedding);
-    });
-    return {
-      vector: embeddings
-    };
-  }
-  const result = textEmbedder.embed(input.text);
-  if (!result.embeddings?.[0]?.floatEmbedding) {
-    throw new PermanentJobError("Failed to generate embedding: Empty result");
-  }
-  const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
-  return {
-    vector: embedding
-  };
-};
-var TFMP_TextClassification = async (input, model, onProgress, signal) => {
-  const TextClassification = await getModelTask(model, {
-    maxCategories: input.maxCategories
-  }, onProgress, signal, TextClassifier);
-  const result = TextClassification.classify(input.text);
-  if (!result.classifications?.[0]?.categories) {
-    throw new PermanentJobError("Failed to classify text: Empty result");
-  }
-  const categories = result.classifications[0].categories.map((category) => ({
-    label: category.categoryName,
-    score: category.score
-  }));
-  return {
-    categories
-  };
-};
-var TFMP_TextLanguageDetection = async (input, model, onProgress, signal) => {
-  const maxLanguages = input.maxLanguages === 0 ? -1 : input.maxLanguages;
-  const textLanguageDetector = await getModelTask(model, {
-    maxLanguages
-  }, onProgress, signal, LanguageDetector);
-  const result = textLanguageDetector.detect(input.text);
-  if (!result.languages?.[0]?.languageCode) {
-    throw new PermanentJobError("Failed to detect language: Empty result");
-  }
-  const languages = result.languages.map((language) => ({
-    language: language.languageCode,
-    score: language.probability
-  }));
-  return {
-    languages
-  };
-};
-var TFMP_Unload = async (input, model, onProgress, signal) => {
-  const model_path = model.provider_config.model_path;
-  onProgress(10, "Unloading model");
-  if (modelTaskCache.has(model_path)) {
-    const cachedTasks = modelTaskCache.get(model_path);
-    for (const cachedTask of cachedTasks) {
-      const task = cachedTask.task;
-      if ("close" in task && typeof task.close === "function")
-        task.close();
-      const task_engine = cachedTask.task_engine;
-      const currentCount = wasm_reference_counts.get(task_engine) || 0;
-      const newCount = currentCount - 1;
-      if (newCount <= 0) {
-        wasm_tasks.delete(task_engine);
-        wasm_reference_counts.delete(task_engine);
-      } else {
-        wasm_reference_counts.set(task_engine, newCount);
-      }
-    }
-    modelTaskCache.delete(model_path);
-  }
-  return {
-    model: input.model
-  };
-};
-var TFMP_ImageSegmentation = async (input, model, onProgress, signal) => {
-  const imageSegmenter = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
-  const result = imageSegmenter.segment(input.image);
-  if (!result.categoryMask) {
-    throw new PermanentJobError("Failed to segment image: Empty result");
-  }
-  const masks = [
-    {
-      label: "segment",
-      score: 1,
-      mask: {
-        data: result.categoryMask.canvas,
-        width: result.categoryMask.width,
-        height: result.categoryMask.height
-      }
-    }
-  ];
-  return {
-    masks
-  };
-};
-var TFMP_ImageEmbedding = async (input, model, onProgress, signal) => {
-  const imageEmbedder = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
-  const result = imageEmbedder.embed(input.image);
-  if (!result.embeddings?.[0]?.floatEmbedding) {
-    throw new PermanentJobError("Failed to generate embedding: Empty result");
-  }
-  const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
-  return {
-    vector: embedding
-  };
-};
-var TFMP_ImageClassification = async (input, model, onProgress, signal) => {
-  const imageClassifier = await getModelTask(model, {
-    maxResults: input.maxCategories
-  }, onProgress, signal, ImageClassifier);
-  const result = imageClassifier.classify(input.image);
-  if (!result.classifications?.[0]?.categories) {
-    throw new PermanentJobError("Failed to classify image: Empty result");
-  }
-  const categories = result.classifications[0].categories.map((category) => ({
-    label: category.categoryName,
-    score: category.score
-  }));
-  return {
-    categories
-  };
-};
-var TFMP_ObjectDetection = async (input, model, onProgress, signal) => {
-  const objectDetector = await getModelTask(model, {
-    scoreThreshold: input.threshold
-  }, onProgress, signal, ObjectDetector);
-  const result = objectDetector.detect(input.image);
-  if (!result.detections) {
-    throw new PermanentJobError("Failed to detect objects: Empty result");
-  }
-  const detections = result.detections.map((detection) => ({
-    label: detection.categories?.[0]?.categoryName || "unknown",
-    score: detection.categories?.[0]?.score || 0,
-    box: {
-      x: detection.boundingBox?.originX || 0,
-      y: detection.boundingBox?.originY || 0,
-      width: detection.boundingBox?.width || 0,
-      height: detection.boundingBox?.height || 0
+    provider_config: {
+      type: "object",
+      description: "Ollama-specific configuration.",
+      properties: {
+        model_name: {
+          type: "string",
+          description: "The Ollama model identifier (e.g., 'llama3.2', 'nomic-embed-text')."
+        },
+        base_url: {
+          type: "string",
+          description: "Base URL for the Ollama server.",
+          default: OLLAMA_DEFAULT_BASE_URL
+        }
+      },
+      required: ["model_name"],
+      additionalProperties: false
     }
-  }));
-  return {
-    detections
-  };
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
 };
-var TFMP_GestureRecognizer = async (input, model, onProgress, signal) => {
-  const gestureRecognizer = await getModelTask(model, {
-    numHands: input.numHands,
-    minHandDetectionConfidence: input.minHandDetectionConfidence,
-    minHandPresenceConfidence: input.minHandPresenceConfidence,
-    minTrackingConfidence: input.minTrackingConfidence
-  }, onProgress, signal, GestureRecognizer);
-  const result = gestureRecognizer.recognize(input.image);
-  if (!result.gestures || !result.landmarks) {
-    throw new PermanentJobError("Failed to recognize gestures: Empty result");
-  }
-  const hands = result.gestures.map((gestures, index) => ({
-    gestures: gestures.map((g) => ({
-      label: g.categoryName,
-      score: g.score
-    })),
-    handedness: result.handedness[index].map((h) => ({
-      label: h.categoryName,
-      score: h.score
-    })),
-    landmarks: result.landmarks[index].map((l) => ({
-      x: l.x,
-      y: l.y,
-      z: l.z
-    })),
-    worldLandmarks: result.worldLandmarks[index].map((l) => ({
-      x: l.x,
-      y: l.y,
-      z: l.z
-    }))
-  }));
-  return {
-    hands
-  };
+var OllamaModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema4.properties,
+    ...OllamaModelSchema.properties
+  },
+  required: [...ModelRecordSchema4.required, ...OllamaModelSchema.required],
+  additionalProperties: false
 };
-var TFMP_HandLandmarker = async (input, model, onProgress, signal) => {
-  const handLandmarker = await getModelTask(model, {
-    numHands: input.numHands,
-    minHandDetectionConfidence: input.minHandDetectionConfidence,
-    minHandPresenceConfidence: input.minHandPresenceConfidence,
-    minTrackingConfidence: input.minTrackingConfidence
-  }, onProgress, signal, HandLandmarker);
-  const result = handLandmarker.detect(input.image);
-  if (!result.landmarks) {
-    throw new PermanentJobError("Failed to detect hand landmarks: Empty result");
-  }
-  const hands = result.landmarks.map((landmarks, index) => ({
-    handedness: result.handedness[index].map((h) => ({
-      label: h.categoryName,
-      score: h.score
-    })),
-    landmarks: landmarks.map((l) => ({
-      x: l.x,
-      y: l.y,
-      z: l.z
-    })),
-    worldLandmarks: result.worldLandmarks[index].map((l) => ({
-      x: l.x,
-      y: l.y,
-      z: l.z
-    }))
-  }));
-  return {
-    hands
-  };
+var OllamaModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema4.properties,
+    ...OllamaModelSchema.properties
+  },
+  required: [...ModelConfigSchema4.required, ...OllamaModelSchema.required],
+  additionalProperties: false
 };
-var TFMP_FaceDetector = async (input, model, onProgress, signal) => {
-  const faceDetector = await getModelTask(model, {
-    minDetectionConfidence: input.minDetectionConfidence,
-    minSuppressionThreshold: input.minSuppressionThreshold
-  }, onProgress, signal, FaceDetector);
-  const result = faceDetector.detect(input.image);
-  if (!result.detections) {
-    throw new PermanentJobError("Failed to detect faces: Empty result");
-  }
-  const faces = result.detections.map((detection) => ({
-    box: {
-      x: detection.boundingBox?.originX || 0,
-      y: detection.boundingBox?.originY || 0,
-      width: detection.boundingBox?.width || 0,
-      height: detection.boundingBox?.height || 0
+// src/provider-openai/common/OpenAI_ModelSchema.ts
+import { ModelConfigSchema as ModelConfigSchema5, ModelRecordSchema as ModelRecordSchema5 } from "@workglow/ai";
+var OpenAiModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: OPENAI,
+      description: "Discriminator: OpenAI cloud provider."
     },
-    keypoints: detection.keypoints?.map((kp) => ({
-      x: kp.x,
-      y: kp.y,
-      label: kp.label
-    })) || [],
-    score: detection.categories?.[0]?.score || 0
-  }));
-  return {
-    faces
-  };
-};
-var TFMP_FaceLandmarker = async (input, model, onProgress, signal) => {
-  const faceLandmarker = await getModelTask(model, {
-    numFaces: input.numFaces,
-    minFaceDetectionConfidence: input.minFaceDetectionConfidence,
-    minFacePresenceConfidence: input.minFacePresenceConfidence,
-    minTrackingConfidence: input.minTrackingConfidence,
-    outputFaceBlendshapes: input.outputFaceBlendshapes,
-    outputFacialTransformationMatrixes: input.outputFacialTransformationMatrixes
-  }, onProgress, signal, FaceLandmarker);
-  const result = faceLandmarker.detect(input.image);
-  if (!result.faceLandmarks) {
-    throw new PermanentJobError("Failed to detect face landmarks: Empty result");
-  }
-  const faces = result.faceLandmarks.map((landmarks, index) => {
-    const face = {
-      landmarks: landmarks.map((l) => ({
-        x: l.x,
-        y: l.y,
-        z: l.z
-      }))
-    };
-    if (result.faceBlendshapes && result.faceBlendshapes[index]) {
-      face.blendshapes = result.faceBlendshapes[index].categories.map((b) => ({
-        label: b.categoryName,
-        score: b.score
-      }));
-    }
-    if (result.facialTransformationMatrixes && result.facialTransformationMatrixes[index]) {
-      face.transformationMatrix = Array.from(result.facialTransformationMatrixes[index].data);
+    provider_config: {
+      type: "object",
+      description: "OpenAI-specific configuration.",
+      properties: {
+        model_name: {
+          type: "string",
+          description: "The OpenAI model identifier (e.g., 'gpt-4o', 'text-embedding-3-small')."
+        },
+        api_key: {
+          type: "string",
+          description: "OpenAI API key. Falls back to default API key if not set."
+        },
+        base_url: {
+          type: "string",
+          description: "Base URL for the OpenAI API. Useful for Azure OpenAI or proxy servers.",
+          default: "https://api.openai.com/v1"
+        },
+        organization: {
+          type: "string",
+          description: "OpenAI organization ID (optional)."
+        }
+      },
+      required: ["model_name"],
+      additionalProperties: false
     }
-    return face;
-  });
-  return {
-    faces
-  };
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
 };
-var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
-  const poseLandmarker = await getModelTask(model, {
-    numPoses: input.numPoses,
-    minPoseDetectionConfidence: input.minPoseDetectionConfidence,
-    minPosePresenceConfidence: input.minPosePresenceConfidence,
-    minTrackingConfidence: input.minTrackingConfidence,
-    outputSegmentationMasks: input.outputSegmentationMasks
-  }, onProgress, signal, PoseLandmarker);
-  const result = poseLandmarker.detect(input.image);
-  if (!result.landmarks) {
-    throw new PermanentJobError("Failed to detect pose landmarks: Empty result");
-  }
-  const poses = result.landmarks.map((landmarks, index) => {
-    const pose = {
-      landmarks: landmarks.map((l) => ({
-        x: l.x,
-        y: l.y,
-        z: l.z,
-        visibility: l.visibility,
-        presence: l.presence
-      })),
-      worldLandmarks: result.worldLandmarks[index].map((l) => ({
-        x: l.x,
-        y: l.y,
-        z: l.z,
-        visibility: l.visibility,
-        presence: l.presence
-      }))
-    };
-    if (result.segmentationMasks && result.segmentationMasks[index]) {
-      const mask = result.segmentationMasks[index];
-      pose.segmentationMask = {
-        data: mask.canvas || mask,
-        width: mask.width,
-        height: mask.height
-      };
-    }
-    return pose;
-  });
-  return {
-    poses
-  };
+var OpenAiModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema5.properties,
+    ...OpenAiModelSchema.properties
+  },
+  required: [...ModelRecordSchema5.required, ...OpenAiModelSchema.required],
+  additionalProperties: false
+};
+var OpenAiModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema5.properties,
+    ...OpenAiModelSchema.properties
+  },
+  required: [...ModelConfigSchema5.required, ...OpenAiModelSchema.required],
+  additionalProperties: false
 };
 // src/tf-mediapipe/common/TFMP_ModelSchema.ts
-import { ModelConfigSchema as ModelConfigSchema2, ModelRecordSchema as ModelRecordSchema2 } from "@workglow/ai";
+import { ModelConfigSchema as ModelConfigSchema6, ModelRecordSchema as ModelRecordSchema6 } from "@workglow/ai";
 var TFMPModelSchema = {
   type: "object",
   properties: {
@@ -1459,181 +1324,180 @@ var TFMPModelSchema = {
 var TFMPModelRecordSchema = {
   type: "object",
   properties: {
-    ...ModelRecordSchema2.properties,
+    ...ModelRecordSchema6.properties,
     ...TFMPModelSchema.properties
   },
-  required: [...ModelRecordSchema2.required, ...TFMPModelSchema.required],
+  required: [...ModelRecordSchema6.required, ...TFMPModelSchema.required],
   additionalProperties: false
 };
 var TFMPModelConfigSchema = {
   type: "object",
   properties: {
-    ...ModelConfigSchema2.properties,
+    ...ModelConfigSchema6.properties,
     ...TFMPModelSchema.properties
   },
-  required: [...ModelConfigSchema2.required, ...TFMPModelSchema.required],
+  required: [...ModelConfigSchema6.required, ...TFMPModelSchema.required],
   additionalProperties: false
 };
-// src/tf-mediapipe/registry/TFMP_Client_RegisterJobFns.ts
-import { AiJob as AiJob3, getAiProviderRegistry as getAiProviderRegistry3 } from "@workglow/ai";
-import { ConcurrencyLimiter as ConcurrencyLimiter3, JobQueueClient as JobQueueClient3, JobQueueServer as JobQueueServer3 } from "@workglow/job-queue";
-import { InMemoryQueueStorage as InMemoryQueueStorage3 } from "@workglow/storage";
-import { getTaskQueueRegistry as getTaskQueueRegistry3 } from "@workglow/task-graph";
-import { globalServiceRegistry as globalServiceRegistry3, WORKER_MANAGER as WORKER_MANAGER2 } from "@workglow/util";
-async function register_TFMP_ClientJobFns(worker, client) {
-  const workerManager = globalServiceRegistry3.get(WORKER_MANAGER2);
-  workerManager.registerWorker(TENSORFLOW_MEDIAPIPE, worker);
-  const aiProviderRegistry = getAiProviderRegistry3();
-  const names = [
+// src/anthropic/AnthropicProvider.ts
+import { AiProvider } from "@workglow/ai";
+class AnthropicProvider extends AiProvider {
+  name = ANTHROPIC;
+  taskTypes = ["TextGenerationTask", "TextRewriterTask", "TextSummaryTask"];
+  constructor(tasks, streamTasks) {
+    super(tasks, streamTasks);
+  }
+}
+// src/google-gemini/GoogleGeminiProvider.ts
+import { AiProvider as AiProvider2 } from "@workglow/ai";
+class GoogleGeminiProvider extends AiProvider2 {
+  name = GOOGLE_GEMINI;
+  taskTypes = [
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask"
+  ];
+  constructor(tasks, streamTasks) {
+    super(tasks, streamTasks);
+  }
+}
+// src/hf-transformers/HuggingFaceTransformersProvider.ts
+init_HFT_Constants();
+import {
+  AiProvider as AiProvider3
+} from "@workglow/ai";
+
+class HuggingFaceTransformersProvider extends AiProvider3 {
+  name = HF_TRANSFORMERS_ONNX;
+  taskTypes = [
     "DownloadModelTask",
     "UnloadModelTask",
     "TextEmbeddingTask",
+    "TextGenerationTask",
+    "TextQuestionAnswerTask",
     "TextLanguageDetectionTask",
     "TextClassificationTask",
+    "TextFillMaskTask",
+    "TextNamedEntityRecognitionTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "TextTranslationTask",
     "ImageSegmentationTask",
+    "ImageToTextTask",
+    "BackgroundRemovalTask",
     "ImageEmbeddingTask",
     "ImageClassificationTask",
     "ObjectDetectionTask"
   ];
-  for (const name of names) {
-    aiProviderRegistry.registerAsWorkerRunFn(TENSORFLOW_MEDIAPIPE, name);
+  constructor(tasks, streamTasks) {
+    super(tasks, streamTasks);
   }
-  if (!client) {
-    const storage = new InMemoryQueueStorage3(TENSORFLOW_MEDIAPIPE);
-    await storage.setupDatabase();
-    const server = new JobQueueServer3(AiJob3, {
-      storage,
-      queueName: TENSORFLOW_MEDIAPIPE,
-      limiter: new ConcurrencyLimiter3(1, 100)
-    });
-    client = new JobQueueClient3({
-      storage,
-      queueName: TENSORFLOW_MEDIAPIPE
-    });
-    client.attach(server);
-    getTaskQueueRegistry3().registerQueue({ server, client, storage });
-    await server.start();
+  async onInitialize(options) {
+    if (options.mode === "inline") {
+      const { env } = await import("@sroussey/transformers");
+      env.backends.onnx.wasm.proxy = true;
+    }
+  }
+  async dispose() {
+    if (this.tasks) {
+      const { clearPipelineCache: clearPipelineCache2 } = await Promise.resolve().then(() => (init_HFT_JobRunFns(), exports_HFT_JobRunFns));
+      clearPipelineCache2();
+    }
   }
 }
-// src/tf-mediapipe/registry/TFMP_Inline_RegisterJobFns.ts
-import { AiJob as AiJob4, getAiProviderRegistry as getAiProviderRegistry4 } from "@workglow/ai";
-import { ConcurrencyLimiter as ConcurrencyLimiter4, JobQueueClient as JobQueueClient4, JobQueueServer as JobQueueServer4 } from "@workglow/job-queue";
-import { InMemoryQueueStorage as InMemoryQueueStorage4 } from "@workglow/storage";
-import { getTaskQueueRegistry as getTaskQueueRegistry4 } from "@workglow/task-graph";
-async function register_TFMP_InlineJobFns(client) {
-  const aiProviderRegistry = getAiProviderRegistry4();
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "DownloadModelTask", TFMP_Download);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "UnloadModelTask", TFMP_Unload);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "TextEmbeddingTask", TFMP_TextEmbedding);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "TextLanguageDetectionTask", TFMP_TextLanguageDetection);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "TextClassificationTask", TFMP_TextClassification);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "ImageSegmentationTask", TFMP_ImageSegmentation);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "ImageEmbeddingTask", TFMP_ImageEmbedding);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "ImageClassificationTask", TFMP_ImageClassification);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "ObjectDetectionTask", TFMP_ObjectDetection);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "GestureRecognizerTask", TFMP_GestureRecognizer);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "HandLandmarkerTask", TFMP_HandLandmarker);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "FaceDetectorTask", TFMP_FaceDetector);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "FaceLandmarkerTask", TFMP_FaceLandmarker);
-  aiProviderRegistry.registerRunFn(TENSORFLOW_MEDIAPIPE, "PoseLandmarkerTask", TFMP_PoseLandmarker);
-  if (!client) {
-    const storage = new InMemoryQueueStorage4(TENSORFLOW_MEDIAPIPE);
-    await storage.setupDatabase();
-    const server = new JobQueueServer4(AiJob4, {
-      storage,
-      queueName: TENSORFLOW_MEDIAPIPE,
-      limiter: new ConcurrencyLimiter4(1, 100)
-    });
-    client = new JobQueueClient4({
-      storage,
-      queueName: TENSORFLOW_MEDIAPIPE
-    });
-    client.attach(server);
-    getTaskQueueRegistry4().registerQueue({ server, client, storage });
-    await server.start();
+// src/provider-ollama/OllamaProvider.ts
+import { AiProvider as AiProvider4 } from "@workglow/ai";
+class OllamaProvider extends AiProvider4 {
+  name = OLLAMA;
+  taskTypes = [
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask"
+  ];
+  constructor(tasks, streamTasks) {
+    super(tasks, streamTasks);
+  }
+}
+// src/provider-openai/OpenAiProvider.ts
+import { AiProvider as AiProvider5 } from "@workglow/ai";
+class OpenAiProvider extends AiProvider5 {
+  name = OPENAI;
+  taskTypes = [
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask"
+  ];
+  constructor(tasks, streamTasks) {
+    super(tasks, streamTasks);
+  }
+}
+// src/tf-mediapipe/TensorFlowMediaPipeProvider.ts
+import { AiProvider as AiProvider6 } from "@workglow/ai";
+class TensorFlowMediaPipeProvider extends AiProvider6 {
+  name = TENSORFLOW_MEDIAPIPE;
+  taskTypes = [
+    "DownloadModelTask",
+    "UnloadModelTask",
+    "TextEmbeddingTask",
+    "TextLanguageDetectionTask",
+    "TextClassificationTask",
+    "ImageSegmentationTask",
+    "ImageEmbeddingTask",
+    "ImageClassificationTask",
+    "ObjectDetectionTask",
+    "GestureRecognizerTask",
+    "HandLandmarkerTask",
+    "FaceDetectorTask",
+    "FaceLandmarkerTask",
+    "PoseLandmarkerTask"
+  ];
+  constructor(tasks) {
+    super(tasks);
   }
 }
-// src/tf-mediapipe/registry/TFMP_Worker_RegisterJobFns.ts
-import {
-  createServiceToken as createServiceToken2,
-  globalServiceRegistry as globalServiceRegistry4,
-  parentPort as parentPort2,
-  WORKER_SERVER as WORKER_SERVER2
-} from "@workglow/util";
-var TFMP_WORKER_JOBRUN = createServiceToken2("worker.ai-provider.tfmp");
-var TFMP_WORKER_JOBRUN_REGISTER = globalServiceRegistry4.register(TFMP_WORKER_JOBRUN, () => {
-  const workerServer = globalServiceRegistry4.get(WORKER_SERVER2);
-  workerServer.registerFunction("DownloadModelTask", TFMP_Download);
-  workerServer.registerFunction("UnloadModelTask", TFMP_Unload);
-  workerServer.registerFunction("TextEmbeddingTask", TFMP_TextEmbedding);
-  workerServer.registerFunction("TextLanguageDetectionTask", TFMP_TextLanguageDetection);
-  workerServer.registerFunction("TextClassificationTask", TFMP_TextClassification);
-  workerServer.registerFunction("ImageSegmentationTask", TFMP_ImageSegmentation);
-  workerServer.registerFunction("ImageEmbeddingTask", TFMP_ImageEmbedding);
-  workerServer.registerFunction("ImageClassificationTask", TFMP_ImageClassification);
-  workerServer.registerFunction("ObjectDetectionTask", TFMP_ObjectDetection);
-  parentPort2.postMessage({ type: "ready" });
-  console.log("TFMP_WORKER_JOBRUN registered");
-  return workerServer;
-}, true);
 export {
-  register_TFMP_InlineJobFns,
-  register_TFMP_ClientJobFns,
-  register_HFT_InlineJobFns,
-  register_HFT_ClientJobFns,
-  clearPipelineCache,
   VisionPipelineUseCase,
   TextPipelineUseCase,
   TextPipelineTask,
-  TFMP_WORKER_JOBRUN_REGISTER,
-  TFMP_WORKER_JOBRUN,
-  TFMP_Unload,
-  TFMP_TextLanguageDetection,
-  TFMP_TextEmbedding,
-  TFMP_TextClassification,
-  TFMP_PoseLandmarker,
-  TFMP_ObjectDetection,
-  TFMP_ImageSegmentation,
-  TFMP_ImageEmbedding,
-  TFMP_ImageClassification,
-  TFMP_HandLandmarker,
-  TFMP_GestureRecognizer,
-  TFMP_FaceLandmarker,
-  TFMP_FaceDetector,
-  TFMP_Download,
+  TensorFlowMediaPipeProvider,
   TFMPModelSchema,
   TFMPModelRecordSchema,
   TFMPModelConfigSchema,
   TENSORFLOW_MEDIAPIPE,
   QuantizationDataType,
   PipelineUseCase,
+  OpenAiProvider,
+  OpenAiModelSchema,
+  OpenAiModelRecordSchema,
+  OpenAiModelConfigSchema,
+  OllamaProvider,
+  OllamaModelSchema,
+  OllamaModelRecordSchema,
+  OllamaModelConfigSchema,
+  OPENAI,
+  OLLAMA_DEFAULT_BASE_URL,
+  OLLAMA,
   MultimodalPipelineUseCase,
+  HuggingFaceTransformersProvider,
   HfTransformersOnnxModelSchema,
   HfTransformersOnnxModelRecordSchema,
   HfTransformersOnnxModelConfigSchema,
   HTF_CACHE_NAME,
   HF_TRANSFORMERS_ONNX,
-  HFT_WORKER_JOBRUN_REGISTER,
-  HFT_WORKER_JOBRUN,
-  HFT_Unload,
-  HFT_TextTranslation,
-  HFT_TextSummary,
-  HFT_TextRewriter,
-  HFT_TextQuestionAnswer,
-  HFT_TextNamedEntityRecognition,
-  HFT_TextLanguageDetection,
-  HFT_TextGeneration,
-  HFT_TextFillMask,
-  HFT_TextEmbedding,
-  HFT_TextClassification,
-  HFT_ObjectDetection,
-  HFT_ImageToText,
-  HFT_ImageSegmentation,
-  HFT_ImageEmbedding,
-  HFT_ImageClassification,
-  HFT_Download,
-  HFT_BackgroundRemoval,
-  AudioPipelineUseCase
+  GoogleGeminiProvider,
+  GeminiModelSchema,
+  GeminiModelRecordSchema,
+  GeminiModelConfigSchema,
+  GOOGLE_GEMINI,
+  AudioPipelineUseCase,
+  AnthropicProvider,
+  AnthropicModelSchema,
+  AnthropicModelRecordSchema,
+  AnthropicModelConfigSchema,
+  ANTHROPIC
 };
 
-//# debugId=1F514E3823F95AA064756E2164756E21
+//# debugId=3A10C01C45D92C7564756E2164756E21