@workglow/ai-provider 0.0.121 → 0.0.123

package/dist/{tf-mediapipe/index.js → provider-tf-mediapipe/runtime.js}

@@ -1,9 +1,54 @@
-import {
-  __require
-} from "../index.browser-6j5pq722.js";
+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/tf-mediapipe/common/TFMP_Constants.ts
+// src/provider-tf-mediapipe/common/TFMP_Client.ts
+var _tasksText;
+var _tasksVision;
+async function loadTfmpTasksTextSDK() {
+  if (!_tasksText) {
+    try {
+      _tasksText = await import("@mediapipe/tasks-text");
+    } catch {
+      throw new Error("@mediapipe/tasks-text is required for TensorFlow MediaPipe text (and related) tasks. Install with: bun add @mediapipe/tasks-text");
+    }
+  }
+  return _tasksText;
+}
+async function loadTfmpTasksVisionSDK() {
+  if (!_tasksVision) {
+    try {
+      _tasksVision = await import("@mediapipe/tasks-vision");
+    } catch {
+      throw new Error("@mediapipe/tasks-vision is required for TensorFlow MediaPipe vision tasks. Install with: bun add @mediapipe/tasks-vision");
+    }
+  }
+  return _tasksVision;
+}
+// src/provider-tf-mediapipe/common/TFMP_Constants.ts
 var TENSORFLOW_MEDIAPIPE = "TENSORFLOW_MEDIAPIPE";
+var TFMP_DEFAULT_TASK_TYPES = [
+  "DownloadModelTask",
+  "UnloadModelTask",
+  "ModelInfoTask",
+  "TextEmbeddingTask",
+  "TextLanguageDetectionTask",
+  "TextClassificationTask",
+  "ImageSegmentationTask",
+  "ImageEmbeddingTask",
+  "ImageClassificationTask",
+  "ObjectDetectionTask",
+  "GestureRecognizerTask",
+  "HandLandmarkerTask",
+  "FaceDetectorTask",
+  "FaceLandmarkerTask",
+  "PoseLandmarkerTask",
+  "ModelSearchTask"
+];
 var TextPipelineTask = {
   "text-embedder": "text-embedder",
   "text-classifier": "text-classifier",
@@ -24,32 +69,55 @@ var TextPipelineTask = {
   "vision-object-detector": "vision-object-detector",
   "vision-pose-landmarker": "vision-pose-landmarker"
 };
-// src/tf-mediapipe/common/TFMP_JobRunFns.ts
-import { PermanentJobError } from "@workglow/job-queue";
-var _textSdk;
-async function loadMediaPipeTextSDK() {
-  if (!_textSdk) {
-    try {
-      _textSdk = await import("@mediapipe/tasks-text");
-    } catch {
-      throw new Error("@mediapipe/tasks-text is required for MediaPipe text tasks. Install it with: bun add @mediapipe/tasks-text");
-    }
-  }
-  return _textSdk;
-}
-var _visionSdk;
-async function loadMediaPipeVisionSDK() {
-  if (!_visionSdk) {
-    try {
-      _visionSdk = await import("@mediapipe/tasks-vision");
-    } catch {
-      throw new Error("@mediapipe/tasks-vision is required for MediaPipe vision tasks. Install it with: bun add @mediapipe/tasks-vision");
-    }
-  }
-  return _visionSdk;
+
+// src/provider-tf-mediapipe/common/TFMP_ModelSearch.ts
+var TFMP_MODELS = [
+  { label: "text-embedder  Universal Sentence Encoder", value: "text-embedder" }
+];
+function createTFMPModelSearch(providerId) {
+  return async () => {
+    const results = TFMP_MODELS.map((m) => ({
+      id: m.value,
+      label: m.label,
+      description: "",
+      record: {
+        model_id: m.value,
+        provider: providerId,
+        title: m.value,
+        description: "",
+        tasks: [],
+        provider_config: { model_path: m.value },
+        metadata: {}
+      },
+      raw: m
+    }));
+    return { results };
+  };
 }
+var TFMP_ModelSearch = createTFMPModelSearch(TENSORFLOW_MEDIAPIPE);
+
+// src/provider-tf-mediapipe/common/TFMP_Download.ts
+import { PermanentJobError as PermanentJobError2 } from "@workglow/job-queue";
+
+// src/provider-tf-mediapipe/common/TFMP_Runtime.ts
+import { PermanentJobError } from "@workglow/job-queue";
 var wasm_tasks = new Map;
 var wasm_reference_counts = new Map;
+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 getWasmTask = async (model, onProgress, signal) => {
   const task_engine = model.provider_config.task_engine;
   if (wasm_tasks.has(task_engine)) {
@@ -59,42 +127,34 @@ var getWasmTask = async (model, onProgress, signal) => {
     throw new PermanentJobError("Aborted job");
   }
   onProgress(0.1, "Loading WASM task");
-  const { FilesetResolver } = await loadMediaPipeTextSDK();
   let wasmFileset;
   switch (task_engine) {
-    case "text":
+    case "vision": {
+      const { FilesetResolver } = await loadTfmpTasksVisionSDK();
+      wasmFileset = await FilesetResolver.forVisionTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm");
+      break;
+    }
+    case "text": {
+      const { FilesetResolver } = await loadTfmpTasksTextSDK();
       wasmFileset = await FilesetResolver.forTextTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-text@latest/wasm");
       break;
-    case "audio":
+    }
+    case "audio": {
+      const { FilesetResolver } = await loadTfmpTasksTextSDK();
       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":
+    }
+    case "genai": {
+      const { FilesetResolver } = await loadTfmpTasksTextSDK();
       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;
@@ -121,71 +181,73 @@ var getModelTask = async (model, options, onProgress, signal, TaskType) => {
   wasm_reference_counts.set(task_engine, (wasm_reference_counts.get(task_engine) || 0) + 1);
   return task;
 };
+
+// src/provider-tf-mediapipe/common/TFMP_Download.ts
 var TFMP_Download = async (input, model, onProgress, signal) => {
   let task;
   switch (model?.provider_config.pipeline) {
     case "text-embedder": {
-      const { TextEmbedder } = await loadMediaPipeTextSDK();
+      const { TextEmbedder } = await loadTfmpTasksTextSDK();
       task = await getModelTask(model, {}, onProgress, signal, TextEmbedder);
       break;
     }
     case "text-classifier": {
-      const { TextClassifier } = await loadMediaPipeTextSDK();
+      const { TextClassifier } = await loadTfmpTasksTextSDK();
       task = await getModelTask(model, {}, onProgress, signal, TextClassifier);
       break;
     }
     case "text-language-detector": {
-      const { LanguageDetector } = await loadMediaPipeTextSDK();
+      const { LanguageDetector } = await loadTfmpTasksTextSDK();
       task = await getModelTask(model, {}, onProgress, signal, LanguageDetector);
       break;
     }
     case "vision-image-classifier": {
-      const { ImageClassifier } = await loadMediaPipeVisionSDK();
+      const { ImageClassifier } = await loadTfmpTasksVisionSDK();
       task = await getModelTask(model, {}, onProgress, signal, ImageClassifier);
       break;
     }
     case "vision-image-embedder": {
-      const { ImageEmbedder } = await loadMediaPipeVisionSDK();
+      const { ImageEmbedder } = await loadTfmpTasksVisionSDK();
       task = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
       break;
     }
     case "vision-image-segmenter": {
-      const { ImageSegmenter } = await loadMediaPipeVisionSDK();
+      const { ImageSegmenter } = await loadTfmpTasksVisionSDK();
       task = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
       break;
     }
     case "vision-object-detector": {
-      const { ObjectDetector } = await loadMediaPipeVisionSDK();
+      const { ObjectDetector } = await loadTfmpTasksVisionSDK();
       task = await getModelTask(model, {}, onProgress, signal, ObjectDetector);
       break;
     }
     case "vision-face-detector": {
-      const { FaceDetector } = await loadMediaPipeVisionSDK();
+      const { FaceDetector } = await loadTfmpTasksVisionSDK();
       task = await getModelTask(model, {}, onProgress, signal, FaceDetector);
       break;
     }
     case "vision-face-landmarker": {
-      const { FaceLandmarker } = await loadMediaPipeVisionSDK();
+      const { FaceLandmarker } = await loadTfmpTasksVisionSDK();
       task = await getModelTask(model, {}, onProgress, signal, FaceLandmarker);
       break;
     }
     case "vision-gesture-recognizer": {
-      const { GestureRecognizer } = await loadMediaPipeVisionSDK();
+      const { GestureRecognizer } = await loadTfmpTasksVisionSDK();
       task = await getModelTask(model, {}, onProgress, signal, GestureRecognizer);
       break;
     }
     case "vision-hand-landmarker": {
-      const { HandLandmarker } = await loadMediaPipeVisionSDK();
+      const { HandLandmarker } = await loadTfmpTasksVisionSDK();
       task = await getModelTask(model, {}, onProgress, signal, HandLandmarker);
       break;
     }
     case "vision-pose-landmarker": {
-      const { PoseLandmarker } = await loadMediaPipeVisionSDK();
+      const { PoseLandmarker } = await loadTfmpTasksVisionSDK();
       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`);
+      throw new PermanentJobError2(`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();
@@ -195,166 +257,82 @@ var TFMP_Download = async (input, model, onProgress, signal) => {
     model: input.model
   };
 };
-var TFMP_TextEmbedding = async (input, model, onProgress, signal) => {
-  const { TextEmbedder } = await loadMediaPipeTextSDK();
-  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 { TextClassifier } = await loadMediaPipeTextSDK();
-  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 { LanguageDetector } = await loadMediaPipeTextSDK();
-  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 loadMediaPipeVisionSDK();
-  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 loadMediaPipeVisionSDK();
-  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 loadMediaPipeVisionSDK();
-  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 loadMediaPipeVisionSDK();
-  const objectDetector = await getModelTask(model, {
-    scoreThreshold: input.threshold
-  }, onProgress, signal, ObjectDetector);
-  const result = objectDetector.detect(input.image);
+
+// src/provider-tf-mediapipe/common/TFMP_FaceDetector.ts
+import { PermanentJobError as PermanentJobError3 } from "@workglow/job-queue";
+var TFMP_FaceDetector = async (input, model, onProgress, signal) => {
+  const { FaceDetector } = await loadTfmpTasksVisionSDK();
+  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 objects: Empty result");
+    throw new PermanentJobError3("Failed to detect faces: Empty result");
   }
-  const detections = result.detections.map((detection) => ({
-    label: detection.categories?.[0]?.categoryName || "unknown",
-    score: detection.categories?.[0]?.score || 0,
+  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
-    }
+    },
+    keypoints: detection.keypoints?.map((kp) => ({
+      x: kp.x,
+      y: kp.y,
+      label: kp.label
+    })) || [],
+    score: detection.categories?.[0]?.score || 0
   }));
   return {
-    detections
+    faces
   };
 };
+
+// src/provider-tf-mediapipe/common/TFMP_FaceLandmarker.ts
+import { PermanentJobError as PermanentJobError4 } from "@workglow/job-queue";
+var TFMP_FaceLandmarker = async (input, model, onProgress, signal) => {
+  const { FaceLandmarker } = await loadTfmpTasksVisionSDK();
+  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 PermanentJobError4("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);
+    }
+    return face;
+  });
+  return {
+    faces
+  };
+};
+
+// src/provider-tf-mediapipe/common/TFMP_GestureRecognizer.ts
+import { PermanentJobError as PermanentJobError5 } from "@workglow/job-queue";
 var TFMP_GestureRecognizer = async (input, model, onProgress, signal) => {
-  const { GestureRecognizer } = await loadMediaPipeVisionSDK();
+  const { GestureRecognizer } = await loadTfmpTasksVisionSDK();
   const gestureRecognizer = await getModelTask(model, {
     numHands: input.numHands,
     minHandDetectionConfidence: input.minHandDetectionConfidence,
@@ -363,7 +341,7 @@ var TFMP_GestureRecognizer = async (input, model, onProgress, signal) => {
   }, onProgress, signal, GestureRecognizer);
   const result = gestureRecognizer.recognize(input.image);
   if (!result.gestures || !result.landmarks) {
-    throw new PermanentJobError("Failed to recognize gestures: Empty result");
+    throw new PermanentJobError5("Failed to recognize gestures: Empty result");
   }
   const hands = result.gestures.map((gestures, index) => ({
     gestures: gestures.map((g) => ({
@@ -389,8 +367,11 @@ var TFMP_GestureRecognizer = async (input, model, onProgress, signal) => {
     hands
   };
 };
+
+// src/provider-tf-mediapipe/common/TFMP_HandLandmarker.ts
+import { PermanentJobError as PermanentJobError6 } from "@workglow/job-queue";
 var TFMP_HandLandmarker = async (input, model, onProgress, signal) => {
-  const { HandLandmarker } = await loadMediaPipeVisionSDK();
+  const { HandLandmarker } = await loadTfmpTasksVisionSDK();
   const handLandmarker = await getModelTask(model, {
     numHands: input.numHands,
     minHandDetectionConfidence: input.minHandDetectionConfidence,
@@ -399,7 +380,7 @@ var TFMP_HandLandmarker = async (input, model, onProgress, signal) => {
   }, onProgress, signal, HandLandmarker);
   const result = handLandmarker.detect(input.image);
   if (!result.landmarks) {
-    throw new PermanentJobError("Failed to detect hand landmarks: Empty result");
+    throw new PermanentJobError6("Failed to detect hand landmarks: Empty result");
   }
   const hands = result.landmarks.map((landmarks, index) => ({
     handedness: result.handedness[index].map((h) => ({
@@ -421,73 +402,113 @@ var TFMP_HandLandmarker = async (input, model, onProgress, signal) => {
     hands
   };
 };
-var TFMP_FaceDetector = async (input, model, onProgress, signal) => {
-  const { FaceDetector } = await loadMediaPipeVisionSDK();
-  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");
+
+// src/provider-tf-mediapipe/common/TFMP_ImageClassification.ts
+import { PermanentJobError as PermanentJobError7 } from "@workglow/job-queue";
+var TFMP_ImageClassification = async (input, model, onProgress, signal) => {
+  const { ImageClassifier } = await loadTfmpTasksVisionSDK();
+  const imageClassifier = await getModelTask(model, {
+    maxResults: input.maxCategories
+  }, onProgress, signal, ImageClassifier);
+  const result = imageClassifier.classify(input.image);
+  if (!result.classifications?.[0]?.categories) {
+    throw new PermanentJobError7("Failed to classify image: 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
-    },
-    keypoints: detection.keypoints?.map((kp) => ({
-      x: kp.x,
-      y: kp.y,
-      label: kp.label
-    })) || [],
-    score: detection.categories?.[0]?.score || 0
+  const categories = result.classifications[0].categories.map((category) => ({
+    label: category.categoryName,
+    score: category.score
   }));
   return {
-    faces
+    categories
   };
 };
-var TFMP_FaceLandmarker = async (input, model, onProgress, signal) => {
-  const { FaceLandmarker } = await loadMediaPipeVisionSDK();
-  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");
+
+// src/provider-tf-mediapipe/common/TFMP_ImageEmbedding.ts
+import { PermanentJobError as PermanentJobError8 } from "@workglow/job-queue";
+var TFMP_ImageEmbedding = async (input, model, onProgress, signal) => {
+  const { ImageEmbedder } = await loadTfmpTasksVisionSDK();
+  const imageEmbedder = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
+  const result = imageEmbedder.embed(input.image);
+  if (!result.embeddings?.[0]?.floatEmbedding) {
+    throw new PermanentJobError8("Failed to generate embedding: 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
-      }));
+  const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
+  return {
+    vector: embedding
+  };
+};
+
+// src/provider-tf-mediapipe/common/TFMP_ImageSegmentation.ts
+import { PermanentJobError as PermanentJobError9 } from "@workglow/job-queue";
+var TFMP_ImageSegmentation = async (input, model, onProgress, signal) => {
+  const { ImageSegmenter } = await loadTfmpTasksVisionSDK();
+  const imageSegmenter = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
+  const result = imageSegmenter.segment(input.image);
+  if (!result.categoryMask) {
+    throw new PermanentJobError9("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
+      }
     }
-    if (result.facialTransformationMatrixes && result.facialTransformationMatrixes[index]) {
-      face.transformationMatrix = Array.from(result.facialTransformationMatrixes[index].data);
+  ];
+  return {
+    masks
+  };
+};
+
+// src/provider-tf-mediapipe/common/TFMP_ModelInfo.ts
+var TFMP_ModelInfo = async (input, model) => {
+  const model_path = model.provider_config.model_path;
+  const is_loaded = modelTaskCache.has(model_path);
+  return {
+    model: input.model,
+    is_local: true,
+    is_remote: false,
+    supports_browser: true,
+    supports_node: false,
+    is_cached: is_loaded,
+    is_loaded,
+    file_sizes: null
+  };
+};
+
+// src/provider-tf-mediapipe/common/TFMP_ObjectDetection.ts
+import { PermanentJobError as PermanentJobError10 } from "@workglow/job-queue";
+var TFMP_ObjectDetection = async (input, model, onProgress, signal) => {
+  const { ObjectDetector } = await loadTfmpTasksVisionSDK();
+  const objectDetector = await getModelTask(model, {
+    scoreThreshold: input.threshold
+  }, onProgress, signal, ObjectDetector);
+  const result = objectDetector.detect(input.image);
+  if (!result.detections) {
+    throw new PermanentJobError10("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
     }
-    return face;
-  });
+  }));
   return {
-    faces
+    detections
   };
 };
+
+// src/provider-tf-mediapipe/common/TFMP_PoseLandmarker.ts
+import { PermanentJobError as PermanentJobError11 } from "@workglow/job-queue";
 var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
-  const { PoseLandmarker } = await loadMediaPipeVisionSDK();
+  const { PoseLandmarker } = await loadTfmpTasksVisionSDK();
   const poseLandmarker = await getModelTask(model, {
     numPoses: input.numPoses,
     minPoseDetectionConfidence: input.minPoseDetectionConfidence,
@@ -497,7 +518,7 @@ var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
   }, onProgress, signal, PoseLandmarker);
   const result = poseLandmarker.detect(input.image);
   if (!result.landmarks) {
-    throw new PermanentJobError("Failed to detect pose landmarks: Empty result");
+    throw new PermanentJobError11("Failed to detect pose landmarks: Empty result");
   }
   const poses = result.landmarks.map((landmarks, index) => {
     const pose = {
@@ -530,20 +551,103 @@ var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
     poses
   };
 };
-var TFMP_ModelInfo = async (input, model) => {
+
+// src/provider-tf-mediapipe/common/TFMP_TextClassification.ts
+import { PermanentJobError as PermanentJobError12 } from "@workglow/job-queue";
+var TFMP_TextClassification = async (input, model, onProgress, signal) => {
+  const { TextClassifier } = await loadTfmpTasksTextSDK();
+  const TextClassification = await getModelTask(model, {
+    maxCategories: input.maxCategories
+  }, onProgress, signal, TextClassifier);
+  const result = TextClassification.classify(input.text);
+  if (!result.classifications?.[0]?.categories) {
+    throw new PermanentJobError12("Failed to classify text: Empty result");
+  }
+  const categories = result.classifications[0].categories.map((category) => ({
+    label: category.categoryName,
+    score: category.score
+  }));
+  return {
+    categories
+  };
+};
+
+// src/provider-tf-mediapipe/common/TFMP_TextEmbedding.ts
+import { PermanentJobError as PermanentJobError13 } from "@workglow/job-queue";
+var TFMP_TextEmbedding = async (input, model, onProgress, signal) => {
+  const { TextEmbedder } = await loadTfmpTasksTextSDK();
+  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 PermanentJobError13("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 PermanentJobError13("Failed to generate embedding: Empty result");
+  }
+  const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
+  return {
+    vector: embedding
+  };
+};
+
+// src/provider-tf-mediapipe/common/TFMP_TextLanguageDetection.ts
+import { PermanentJobError as PermanentJobError14 } from "@workglow/job-queue";
+var TFMP_TextLanguageDetection = async (input, model, onProgress, signal) => {
+  const maxLanguages = input.maxLanguages === 0 ? -1 : input.maxLanguages;
+  const { LanguageDetector } = await loadTfmpTasksTextSDK();
+  const textLanguageDetector = await getModelTask(model, {
+    maxLanguages
+  }, onProgress, signal, LanguageDetector);
+  const result = textLanguageDetector.detect(input.text);
+  if (!result.languages?.[0]?.languageCode) {
+    throw new PermanentJobError14("Failed to detect language: Empty result");
+  }
+  const languages = result.languages.map((language) => ({
+    language: language.languageCode,
+    score: language.probability
+  }));
+  return {
+    languages
+  };
+};
+
+// src/provider-tf-mediapipe/common/TFMP_Unload.ts
+var TFMP_Unload = async (input, model, onProgress, _signal) => {
   const model_path = model.provider_config.model_path;
-  const is_loaded = modelTaskCache.has(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,
-    is_local: true,
-    is_remote: false,
-    supports_browser: true,
-    supports_node: false,
-    is_cached: is_loaded,
-    is_loaded,
-    file_sizes: null
+    model: input.model
   };
 };
+
+// src/provider-tf-mediapipe/common/TFMP_JobRunFns.ts
 var TFMP_TASKS = {
   DownloadModelTask: TFMP_Download,
   UnloadModelTask: TFMP_Unload,
@@ -559,120 +663,53 @@ var TFMP_TASKS = {
   HandLandmarkerTask: TFMP_HandLandmarker,
   FaceDetectorTask: TFMP_FaceDetector,
   FaceLandmarkerTask: TFMP_FaceLandmarker,
-  PoseLandmarkerTask: TFMP_PoseLandmarker
-};
-// src/tf-mediapipe/common/TFMP_ModelSchema.ts
-import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai";
-var TFMPModelSchema = {
-  type: "object",
-  properties: {
-    provider: {
-      const: TENSORFLOW_MEDIAPIPE,
-      description: "Discriminator: TensorFlow MediaPipe backend."
-    },
-    provider_config: {
-      type: "object",
-      description: "TensorFlow MediaPipe-specific options.",
-      properties: {
-        model_path: {
-          type: "string",
-          description: "Filesystem path or URI for the ONNX model."
-        },
-        task_engine: {
-          type: "string",
-          enum: ["text", "audio", "vision", "genai"],
-          description: "Task engine for the MediaPipe model."
-        },
-        pipeline: {
-          type: "string",
-          enum: Object.values(TextPipelineTask),
-          description: "Pipeline task type for the MediaPipe model."
-        }
-      },
-      required: ["model_path", "task_engine", "pipeline"],
-      additionalProperties: false
-    }
-  },
-  required: ["provider", "provider_config"],
-  additionalProperties: true
+  PoseLandmarkerTask: TFMP_PoseLandmarker,
+  ModelSearchTask: TFMP_ModelSearch
 };
-var TFMPModelRecordSchema = {
-  type: "object",
-  properties: {
-    ...ModelRecordSchema.properties,
-    ...TFMPModelSchema.properties
-  },
-  required: [...ModelRecordSchema.required, ...TFMPModelSchema.required],
-  additionalProperties: false
-};
-var TFMPModelConfigSchema = {
-  type: "object",
-  properties: {
-    ...ModelConfigSchema.properties,
-    ...TFMPModelSchema.properties
-  },
-  required: [...ModelConfigSchema.required, ...TFMPModelSchema.required],
-  additionalProperties: false
-};
-// src/tf-mediapipe/TensorFlowMediaPipeProvider.ts
-import { AiProvider } from "@workglow/ai";
+
+// src/provider-tf-mediapipe/TensorFlowMediaPipeQueuedProvider.ts
+import { QueuedAiProvider } from "@workglow/ai";
+class TensorFlowMediaPipeQueuedProvider extends QueuedAiProvider {
+  name = TENSORFLOW_MEDIAPIPE;
+  isLocal = true;
+  supportsBrowser = true;
+  taskTypes = TFMP_DEFAULT_TASK_TYPES;
+  constructor(tasks, reactiveTasks) {
+    super(tasks, undefined, reactiveTasks);
+  }
+}
+
+// src/provider-tf-mediapipe/registerTensorFlowMediaPipeInline.ts
+async function registerTensorFlowMediaPipeInline(options) {
+  await new TensorFlowMediaPipeQueuedProvider(TFMP_TASKS).register(options ?? {});
+}
+// src/provider-tf-mediapipe/registerTensorFlowMediaPipeWorker.ts
+import { getLogger, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
+
+// src/provider-tf-mediapipe/TensorFlowMediaPipeProvider.ts
+import { AiProvider } from "@workglow/ai/worker";
 class TensorFlowMediaPipeProvider extends AiProvider {
   name = TENSORFLOW_MEDIAPIPE;
   isLocal = true;
   supportsBrowser = true;
-  taskTypes = [
-    "DownloadModelTask",
-    "UnloadModelTask",
-    "ModelInfoTask",
-    "TextEmbeddingTask",
-    "TextLanguageDetectionTask",
-    "TextClassificationTask",
-    "ImageSegmentationTask",
-    "ImageEmbeddingTask",
-    "ImageClassificationTask",
-    "ObjectDetectionTask",
-    "GestureRecognizerTask",
-    "HandLandmarkerTask",
-    "FaceDetectorTask",
-    "FaceLandmarkerTask",
-    "PoseLandmarkerTask"
-  ];
+  taskTypes = TFMP_DEFAULT_TASK_TYPES;
   constructor(tasks, reactiveTasks) {
     super(tasks, undefined, reactiveTasks);
   }
 }
-// src/tf-mediapipe/TFMP_Worker.ts
-import { getLogger, globalServiceRegistry, WORKER_SERVER } from "@workglow/util";
-function TFMP_WORKER_JOBRUN_REGISTER() {
+
+// src/provider-tf-mediapipe/registerTensorFlowMediaPipeWorker.ts
+async function registerTensorFlowMediaPipeWorker() {
   const workerServer = globalServiceRegistry.get(WORKER_SERVER);
   new TensorFlowMediaPipeProvider(TFMP_TASKS).registerOnWorkerServer(workerServer);
   workerServer.sendReady();
-  getLogger().info("TFMP_WORKER_JOBRUN registered");
+  getLogger().info("TensorFlow MediaPipe worker job run functions registered");
 }
 export {
-  TextPipelineTask,
-  TensorFlowMediaPipeProvider,
-  TFMP_WORKER_JOBRUN_REGISTER,
-  TFMP_Unload,
-  TFMP_TextLanguageDetection,
-  TFMP_TextEmbedding,
-  TFMP_TextClassification,
-  TFMP_TASKS,
-  TFMP_PoseLandmarker,
-  TFMP_ObjectDetection,
-  TFMP_ModelInfo,
-  TFMP_ImageSegmentation,
-  TFMP_ImageEmbedding,
-  TFMP_ImageClassification,
-  TFMP_HandLandmarker,
-  TFMP_GestureRecognizer,
-  TFMP_FaceLandmarker,
-  TFMP_FaceDetector,
-  TFMP_Download,
-  TFMPModelSchema,
-  TFMPModelRecordSchema,
-  TFMPModelConfigSchema,
-  TENSORFLOW_MEDIAPIPE
+  registerTensorFlowMediaPipeWorker,
+  registerTensorFlowMediaPipeInline,
+  loadTfmpTasksVisionSDK,
+  loadTfmpTasksTextSDK
 };
 
-//# debugId=032077646512DCA964756E2164756E21
+//# debugId=B31D98746E6C8CAF64756E2164756E21