@workglow/tf-mediapipe 0.2.34 → 0.2.36

package/dist/ai-runtime.js

@@ -27,261 +27,45 @@ async function loadTfmpTasksVisionSDK() {
 // src/ai/registerTensorFlowMediaPipeInline.ts
 import { registerProviderInline } from "@workglow/ai/provider-utils";
 
-// src/ai/common/TFMP_ModelSearch.ts
-import { filterModelSearchResultsByQuery } from "@workglow/ai/provider-utils";
-
-// src/ai/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"
+// src/ai/common/TFMP_CapabilitySets.ts
+var TFMP_TEXT_EMBEDDING = ["text.embedding"];
+var TFMP_TEXT_CLASSIFICATION = ["text.classification"];
+var TFMP_TEXT_LANGUAGE_DETECTION = [
+  "text.language-detection"
 ];
-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/ai/common/TFMP_ModelSearch.ts
-var TFMP_MODEL_RESULTS = [
-  {
-    id: "universal-sentence-encoder",
-    label: "Universal Sentence Encoder",
-    description: "Text embedding model",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "Universal Sentence Encoder",
-      description: "Universal Sentence Encoder",
-      tasks: ["TextEmbeddingTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-tasks/text_embedder/universal_sentence_encoder.tflite",
-        task_engine: "text",
-        pipeline: "text-embedder"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "language-detector",
-    label: "MediaPipe Language Detector",
-    description: "Language detection model",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "MediaPipe Language Detector",
-      description: "MediaPipe Language Detector",
-      tasks: ["TextLanguageDetectionTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-models/language_detector/language_detector/float32/latest/language_detector.tflite",
-        task_engine: "text",
-        pipeline: "text-language-detector"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "bert-text-classifier",
-    label: "MediaPipe BERT Text Classifier",
-    description: "Text classification model",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "MediaPipe BERT Text Classifier",
-      description: "MediaPipe BERT Text Classifier",
-      tasks: ["TextClassificationTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-tasks/text_classifier/bert_text_classifier.tflite",
-        task_engine: "text",
-        pipeline: "text-classifier"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "image-embedder",
-    label: "MediaPipe Image Embedder",
-    description: "Image embedding model",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "MediaPipe Image Embedder",
-      description: "MediaPipe Image Embedder",
-      tasks: ["ImageEmbeddingTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-models/image_embedder/mobilenet_v3_small/float32/1/mobilenet_v3_small.tflite",
-        task_engine: "vision",
-        pipeline: "vision-image-embedder"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "efficientnet-lite0",
-    label: "EfficientNet Lite0",
-    description: "Image classification model",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "EfficientNet Lite0",
-      description: "Image classification model",
-      tasks: ["ImageClassificationTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-models/image_classifier/efficientnet_lite0/float32/1/efficientnet_lite0.tflite",
-        task_engine: "vision",
-        pipeline: "vision-image-classifier"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "efficientdet-lite0",
-    label: "Efficient Object Detector Lite0",
-    description: "Object detection model",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "Efficient Object Detector Lite0",
-      description: "Object detection model",
-      tasks: ["ObjectDetectionTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-models/object_detector/efficientdet_lite0/float32/1/efficientdet_lite0.tflite",
-        task_engine: "vision",
-        pipeline: "vision-object-detector"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "deeplabv3",
-    label: "Efficient Image Segmenter Lite0",
-    description: "Image segmentation model",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "Efficient Image Segmenter Lite0",
-      description: "Image segmentation model",
-      tasks: ["ImageSegmentationTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-assets/deeplabv3.tflite?generation=1661875711618421",
-        task_engine: "vision",
-        pipeline: "vision-image-segmenter"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "face-landmarker",
-    label: "Face Landmarker",
-    description: "Detects 478 facial landmarks with blendshapes",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "Face Landmarker",
-      description: "Detects 478 facial landmarks with blendshapes",
-      tasks: ["FaceLandmarkerTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task",
-        task_engine: "vision",
-        pipeline: "vision-face-landmarker"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "gesture-recognizer",
-    label: "Gesture Recognizer",
-    description: "Recognizes hand gestures such as thumbs up and victory",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "Gesture Recognizer",
-      description: "Recognizes hand gestures such as thumbs up and victory",
-      tasks: ["GestureRecognizerTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-models/gesture_recognizer/gesture_recognizer/float16/1/gesture_recognizer.task",
-        task_engine: "vision",
-        pipeline: "vision-gesture-recognizer"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "hand-landmarker",
-    label: "Hand Landmarker",
-    description: "Detects 21 hand landmarks",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "Hand Landmarker",
-      description: "Detects 21 hand landmarks",
-      tasks: ["HandLandmarkerTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task",
-        task_engine: "vision",
-        pipeline: "vision-hand-landmarker"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  },
-  {
-    id: "pose-landmarker",
-    label: "Pose Landmarker",
-    description: "Detects 33 body pose landmarks",
-    record: {
-      provider: TENSORFLOW_MEDIAPIPE,
-      title: "Pose Landmarker",
-      description: "Detects 33 body pose landmarks",
-      tasks: ["PoseLandmarkerTask"],
-      provider_config: {
-        model_path: "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_lite/float16/1/pose_landmarker_lite.task",
-        task_engine: "vision",
-        pipeline: "vision-pose-landmarker"
-      },
-      metadata: {}
-    },
-    raw: { source: "mediapipe" }
-  }
+var TFMP_IMAGE_CLASSIFICATION = ["image.classification"];
+var TFMP_IMAGE_EMBEDDING = ["image.embedding"];
+var TFMP_IMAGE_SEGMENTATION = ["image.segmentation"];
+var TFMP_IMAGE_OBJECT_DETECTION = [
+  "image.object-detection"
+];
+var TFMP_VISION_FACE_DETECTION = ["vision.face-detection"];
+var TFMP_VISION_FACE_LANDMARKS = ["vision.face-landmarks"];
+var TFMP_VISION_HAND_LANDMARKS = ["vision.hand-landmarks"];
+var TFMP_VISION_POSE_LANDMARKS = ["vision.pose-landmarks"];
+var TFMP_VISION_GESTURE = ["vision.gesture"];
+var TFMP_MODEL_DOWNLOAD = ["model.download"];
+var TFMP_MODEL_UNLOAD = ["model.download-remove"];
+var TFMP_MODEL_SEARCH = ["model.search"];
+var TFMP_MODEL_INFO = ["model.info"];
+var TFMP_CAPABILITY_SETS = [
+  TFMP_TEXT_EMBEDDING,
+  TFMP_TEXT_CLASSIFICATION,
+  TFMP_TEXT_LANGUAGE_DETECTION,
+  TFMP_IMAGE_CLASSIFICATION,
+  TFMP_IMAGE_EMBEDDING,
+  TFMP_IMAGE_SEGMENTATION,
+  TFMP_IMAGE_OBJECT_DETECTION,
+  TFMP_VISION_FACE_DETECTION,
+  TFMP_VISION_FACE_LANDMARKS,
+  TFMP_VISION_HAND_LANDMARKS,
+  TFMP_VISION_POSE_LANDMARKS,
+  TFMP_VISION_GESTURE,
+  TFMP_MODEL_DOWNLOAD,
+  TFMP_MODEL_UNLOAD,
+  TFMP_MODEL_SEARCH,
+  TFMP_MODEL_INFO
 ];
-function createTFMPModelSearch(providerId) {
-  return async (input) => {
-    const results = filterModelSearchResultsByQuery(TFMP_MODEL_RESULTS.map((result) => ({
-      ...result,
-      record: { ...result.record, provider: providerId }
-    })), input.query);
-    return { results };
-  };
-}
-var TFMP_ModelSearch = createTFMPModelSearch(TENSORFLOW_MEDIAPIPE);
 
 // src/ai/common/TFMP_Download.ts
 import { PermanentJobError as PermanentJobError2 } from "@workglow/job-queue";
@@ -305,7 +89,7 @@ var optionsMatch = (opts1, opts2) => {
     return val1 === val2;
   });
 };
-var getWasmTask = async (model, onProgress, signal) => {
+var getWasmTask = async (model, emit, signal) => {
   const task_engine = model.provider_config.task_engine;
   if (wasm_tasks.has(task_engine)) {
     return wasm_tasks.get(task_engine);
@@ -313,7 +97,7 @@ var getWasmTask = async (model, onProgress, signal) => {
   if (signal.aborted) {
     throw new PermanentJobError("Aborted job");
   }
-  onProgress(0.1, "Loading WASM task");
+  emit({ type: "phase", message: "Loading WASM task", progress: 0.1 });
   let wasmFileset;
   switch (task_engine) {
     case "vision": {
@@ -342,7 +126,7 @@ var getWasmTask = async (model, onProgress, signal) => {
   wasm_tasks.set(task_engine, wasmFileset);
   return wasmFileset;
 };
-var getModelTask = async (model, options, onProgress, signal, TaskType) => {
+var getModelTask = async (model, options, emit, signal, TaskType) => {
   const model_path = model.provider_config.model_path;
   const task_engine = model.provider_config.task_engine;
   const cachedTasks = modelTaskCache.get(model_path);
@@ -352,8 +136,8 @@ var getModelTask = async (model, options, onProgress, signal, TaskType) => {
       return matchedTask.task;
     }
   }
-  const wasmFileset = await getWasmTask(model, onProgress, signal);
-  onProgress(0.2, "Creating model task");
+  const wasmFileset = await getWasmTask(model, emit, signal);
+  emit({ type: "phase", message: "Creating model task", progress: 0.2 });
   const task = await TaskType.createFromOptions(wasmFileset, {
     baseOptions: {
       modelAssetPath: model_path
@@ -370,89 +154,88 @@ var getModelTask = async (model, options, onProgress, signal, TaskType) => {
 };
 
 // src/ai/common/TFMP_Download.ts
-var TFMP_Download = async (input, model, onProgress, signal) => {
+var TFMP_Download = async (input, model, signal, emit) => {
+  const pipeline = model?.provider_config.pipeline;
   let task;
-  switch (model?.provider_config.pipeline) {
+  switch (pipeline) {
     case "text-embedder": {
       const { TextEmbedder } = await loadTfmpTasksTextSDK();
-      task = await getModelTask(model, {}, onProgress, signal, TextEmbedder);
+      task = await getModelTask(model, {}, emit, signal, TextEmbedder);
       break;
     }
     case "text-classifier": {
       const { TextClassifier } = await loadTfmpTasksTextSDK();
-      task = await getModelTask(model, {}, onProgress, signal, TextClassifier);
+      task = await getModelTask(model, {}, emit, signal, TextClassifier);
       break;
     }
     case "text-language-detector": {
       const { LanguageDetector } = await loadTfmpTasksTextSDK();
-      task = await getModelTask(model, {}, onProgress, signal, LanguageDetector);
+      task = await getModelTask(model, {}, emit, signal, LanguageDetector);
       break;
     }
     case "vision-image-classifier": {
       const { ImageClassifier } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, ImageClassifier);
+      task = await getModelTask(model, {}, emit, signal, ImageClassifier);
       break;
     }
     case "vision-image-embedder": {
       const { ImageEmbedder } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
+      task = await getModelTask(model, {}, emit, signal, ImageEmbedder);
       break;
     }
     case "vision-image-segmenter": {
       const { ImageSegmenter } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
+      task = await getModelTask(model, {}, emit, signal, ImageSegmenter);
       break;
     }
     case "vision-object-detector": {
       const { ObjectDetector } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, ObjectDetector);
+      task = await getModelTask(model, {}, emit, signal, ObjectDetector);
       break;
     }
     case "vision-face-detector": {
       const { FaceDetector } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, FaceDetector);
+      task = await getModelTask(model, {}, emit, signal, FaceDetector);
       break;
     }
     case "vision-face-landmarker": {
       const { FaceLandmarker } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, FaceLandmarker);
+      task = await getModelTask(model, {}, emit, signal, FaceLandmarker);
       break;
     }
     case "vision-gesture-recognizer": {
       const { GestureRecognizer } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, GestureRecognizer);
+      task = await getModelTask(model, {}, emit, signal, GestureRecognizer);
       break;
     }
     case "vision-hand-landmarker": {
       const { HandLandmarker } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, HandLandmarker);
+      task = await getModelTask(model, {}, emit, signal, HandLandmarker);
       break;
     }
     case "vision-pose-landmarker": {
       const { PoseLandmarker } = await loadTfmpTasksVisionSDK();
-      task = await getModelTask(model, {}, onProgress, signal, PoseLandmarker);
+      task = await getModelTask(model, {}, emit, signal, PoseLandmarker);
       break;
     }
     default:
-      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`);
+      throw new PermanentJobError2(`Invalid pipeline: ${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");
+  emit({ type: "phase", message: "Pipeline loaded", progress: 0.9 });
   task.close();
-  const task_engine = model?.provider_config.task_engine;
+  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
-  };
+  emit({ type: "finish", data: { model: input.model } });
 };
 
 // src/ai/common/TFMP_FaceDetector.ts
 import { PermanentJobError as PermanentJobError3 } from "@workglow/job-queue";
-var TFMP_FaceDetector = async (input, model, onProgress, signal) => {
+var TFMP_FaceDetector = async (input, model, signal, emit) => {
   const { FaceDetector } = await loadTfmpTasksVisionSDK();
   const faceDetector = await getModelTask(model, {
     minDetectionConfidence: input.minDetectionConfidence,
     minSuppressionThreshold: input.minSuppressionThreshold
-  }, onProgress, signal, FaceDetector);
+  }, emit, signal, FaceDetector);
   const result = faceDetector.detect(input.image);
   if (!result.detections) {
     throw new PermanentJobError3("Failed to detect faces: Empty result");
@@ -471,14 +254,12 @@ var TFMP_FaceDetector = async (input, model, onProgress, signal) => {
     })) || [],
     score: detection.categories?.[0]?.score || 0
   }));
-  return {
-    faces
-  };
+  emit({ type: "finish", data: { faces } });
 };
 
 // src/ai/common/TFMP_FaceLandmarker.ts
 import { PermanentJobError as PermanentJobError4 } from "@workglow/job-queue";
-var TFMP_FaceLandmarker = async (input, model, onProgress, signal) => {
+var TFMP_FaceLandmarker = async (input, model, signal, emit) => {
   const { FaceLandmarker } = await loadTfmpTasksVisionSDK();
   const faceLandmarker = await getModelTask(model, {
     numFaces: input.numFaces,
@@ -487,7 +268,7 @@ var TFMP_FaceLandmarker = async (input, model, onProgress, signal) => {
     minTrackingConfidence: input.minTrackingConfidence,
     outputFaceBlendshapes: input.outputFaceBlendshapes,
     outputFacialTransformationMatrixes: input.outputFacialTransformationMatrixes
-  }, onProgress, signal, FaceLandmarker);
+  }, emit, signal, FaceLandmarker);
   const result = faceLandmarker.detect(input.image);
   if (!result.faceLandmarks) {
     throw new PermanentJobError4("Failed to detect face landmarks: Empty result");
@@ -511,21 +292,19 @@ var TFMP_FaceLandmarker = async (input, model, onProgress, signal) => {
     }
     return face;
   });
-  return {
-    faces
-  };
+  emit({ type: "finish", data: { faces } });
 };
 
 // src/ai/common/TFMP_GestureRecognizer.ts
 import { PermanentJobError as PermanentJobError5 } from "@workglow/job-queue";
-var TFMP_GestureRecognizer = async (input, model, onProgress, signal) => {
+var TFMP_GestureRecognizer = async (input, model, signal, emit) => {
   const { GestureRecognizer } = await loadTfmpTasksVisionSDK();
   const gestureRecognizer = await getModelTask(model, {
     numHands: input.numHands,
     minHandDetectionConfidence: input.minHandDetectionConfidence,
     minHandPresenceConfidence: input.minHandPresenceConfidence,
     minTrackingConfidence: input.minTrackingConfidence
-  }, onProgress, signal, GestureRecognizer);
+  }, emit, signal, GestureRecognizer);
   const result = gestureRecognizer.recognize(input.image);
   if (!result.gestures || !result.landmarks) {
     throw new PermanentJobError5("Failed to recognize gestures: Empty result");
@@ -550,21 +329,19 @@ var TFMP_GestureRecognizer = async (input, model, onProgress, signal) => {
       z: l.z
     }))
   }));
-  return {
-    hands
-  };
+  emit({ type: "finish", data: { hands } });
 };
 
 // src/ai/common/TFMP_HandLandmarker.ts
 import { PermanentJobError as PermanentJobError6 } from "@workglow/job-queue";
-var TFMP_HandLandmarker = async (input, model, onProgress, signal) => {
+var TFMP_HandLandmarker = async (input, model, signal, emit) => {
   const { HandLandmarker } = await loadTfmpTasksVisionSDK();
   const handLandmarker = await getModelTask(model, {
     numHands: input.numHands,
     minHandDetectionConfidence: input.minHandDetectionConfidence,
     minHandPresenceConfidence: input.minHandPresenceConfidence,
     minTrackingConfidence: input.minTrackingConfidence
-  }, onProgress, signal, HandLandmarker);
+  }, emit, signal, HandLandmarker);
   const result = handLandmarker.detect(input.image);
   if (!result.landmarks) {
     throw new PermanentJobError6("Failed to detect hand landmarks: Empty result");
@@ -585,18 +362,16 @@ var TFMP_HandLandmarker = async (input, model, onProgress, signal) => {
       z: l.z
     }))
   }));
-  return {
-    hands
-  };
+  emit({ type: "finish", data: { hands } });
 };
 
 // src/ai/common/TFMP_ImageClassification.ts
 import { PermanentJobError as PermanentJobError7 } from "@workglow/job-queue";
-var TFMP_ImageClassification = async (input, model, onProgress, signal) => {
+var TFMP_ImageClassification = async (input, model, signal, emit) => {
   const { ImageClassifier } = await loadTfmpTasksVisionSDK();
   const imageClassifier = await getModelTask(model, {
     maxResults: input.maxCategories
-  }, onProgress, signal, ImageClassifier);
+  }, emit, signal, ImageClassifier);
   const result = imageClassifier.classify(input.image);
   if (!result.classifications?.[0]?.categories) {
     throw new PermanentJobError7("Failed to classify image: Empty result");
@@ -605,16 +380,14 @@ var TFMP_ImageClassification = async (input, model, onProgress, signal) => {
     label: category.categoryName,
     score: category.score
   }));
-  return {
-    categories
-  };
+  emit({ type: "finish", data: { categories } });
 };
 
 // src/ai/common/TFMP_ImageEmbedding.ts
 import { PermanentJobError as PermanentJobError8 } from "@workglow/job-queue";
-var TFMP_ImageEmbedding = async (input, model, onProgress, signal) => {
+var TFMP_ImageEmbedding = async (input, model, signal, emit) => {
   const { ImageEmbedder } = await loadTfmpTasksVisionSDK();
-  const imageEmbedder = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
+  const imageEmbedder = await getModelTask(model, {}, emit, signal, ImageEmbedder);
   if (Array.isArray(input.image)) {
     const vectors = [];
     for (const image of input.image) {
@@ -624,23 +397,22 @@ var TFMP_ImageEmbedding = async (input, model, onProgress, signal) => {
       }
       vectors.push(Float32Array.from(result2.embeddings[0].floatEmbedding));
     }
-    return { vector: vectors };
+    emit({ type: "finish", data: { vector: vectors } });
+    return;
   }
   const result = imageEmbedder.embed(input.image);
   if (!result.embeddings?.[0]?.floatEmbedding) {
     throw new PermanentJobError8("Failed to generate embedding: Empty result");
   }
   const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
-  return {
-    vector: embedding
-  };
+  emit({ type: "finish", data: { vector: embedding } });
 };
 
 // src/ai/common/TFMP_ImageSegmentation.ts
 import { PermanentJobError as PermanentJobError9 } from "@workglow/job-queue";
-var TFMP_ImageSegmentation = async (input, model, onProgress, signal) => {
+var TFMP_ImageSegmentation = async (input, model, signal, emit) => {
   const { ImageSegmenter } = await loadTfmpTasksVisionSDK();
-  const imageSegmenter = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
+  const imageSegmenter = await getModelTask(model, {}, emit, signal, ImageSegmenter);
   const result = imageSegmenter.segment(input.image);
   if (!result.categoryMask) {
     throw new PermanentJobError9("Failed to segment image: Empty result");
@@ -656,16 +428,14 @@ var TFMP_ImageSegmentation = async (input, model, onProgress, signal) => {
       }
     }
   ];
-  return {
-    masks
-  };
+  emit({ type: "finish", data: { masks } });
 };
 
 // src/ai/common/TFMP_ModelInfo.ts
 var TFMP_EMBEDDING_DIMENSIONS = {
   "universal-sentence-encoder": { native_dimensions: 512, mrl: false }
 };
-var TFMP_ModelInfo = async (input, model) => {
+var TFMP_ModelInfo = async (input, model, _signal, emit) => {
   if (input.detail === "dimensions") {
     const pc = model?.provider_config;
     let native_dimensions = typeof pc?.native_dimensions === "number" ? pc.native_dimensions : undefined;
@@ -677,40 +447,303 @@ var TFMP_ModelInfo = async (input, model) => {
         native_dimensions = known.native_dimensions;
       }
     }
-    return {
+    emit({
+      type: "finish",
+      data: {
+        model: input.model,
+        is_local: true,
+        is_remote: false,
+        supports_browser: true,
+        supports_node: false,
+        is_cached: false,
+        is_loaded: false,
+        file_sizes: null,
+        ...native_dimensions !== undefined ? { native_dimensions } : {},
+        ...mrl ? { mrl } : {}
+      }
+    });
+    return;
+  }
+  const model_path = model.provider_config.model_path;
+  const is_loaded = modelTaskCache.has(model_path);
+  emit({
+    type: "finish",
+    data: {
       model: input.model,
       is_local: true,
       is_remote: false,
       supports_browser: true,
       supports_node: false,
-      is_cached: false,
-      is_loaded: false,
-      file_sizes: null,
-      ...native_dimensions !== undefined ? { native_dimensions } : {},
-      ...mrl ? { mrl } : {}
-    };
-  }
-  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
-  };
+      is_cached: is_loaded,
+      is_loaded,
+      file_sizes: null
+    }
+  });
 };
 
+// src/ai/common/TFMP_ModelSearch.ts
+import { filterModelSearchResultsByQuery } from "@workglow/ai/provider-utils";
+
+// src/ai/common/TFMP_Constants.ts
+var TENSORFLOW_MEDIAPIPE = "TENSORFLOW_MEDIAPIPE";
+var TFMP_DEFAULT_TASK_TYPES = [
+  "ModelDownloadTask",
+  "ModelDownloadRemoveTask",
+  "ModelInfoTask",
+  "TextEmbeddingTask",
+  "TextLanguageDetectionTask",
+  "TextClassificationTask",
+  "ImageSegmentationTask",
+  "ImageEmbeddingTask",
+  "ImageClassificationTask",
+  "ObjectDetectionTask",
+  "GestureRecognizerTask",
+  "HandLandmarkerTask",
+  "FaceDetectorTask",
+  "FaceLandmarkerTask",
+  "PoseLandmarkerTask",
+  "ModelSearchTask"
+];
+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/ai/common/TFMP_ModelSearch.ts
+var TFMP_MODEL_RESULTS = [
+  {
+    id: "universal-sentence-encoder",
+    label: "Universal Sentence Encoder",
+    description: "Text embedding model",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "Universal Sentence Encoder",
+      description: "Universal Sentence Encoder",
+      capabilities: ["text.embedding"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-tasks/text_embedder/universal_sentence_encoder.tflite",
+        task_engine: "text",
+        pipeline: "text-embedder"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "language-detector",
+    label: "MediaPipe Language Detector",
+    description: "Language detection model",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "MediaPipe Language Detector",
+      description: "MediaPipe Language Detector",
+      capabilities: ["text.language-detection"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-models/language_detector/language_detector/float32/latest/language_detector.tflite",
+        task_engine: "text",
+        pipeline: "text-language-detector"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "bert-text-classifier",
+    label: "MediaPipe BERT Text Classifier",
+    description: "Text classification model",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "MediaPipe BERT Text Classifier",
+      description: "MediaPipe BERT Text Classifier",
+      capabilities: ["text.classification"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-tasks/text_classifier/bert_text_classifier.tflite",
+        task_engine: "text",
+        pipeline: "text-classifier"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "image-embedder",
+    label: "MediaPipe Image Embedder",
+    description: "Image embedding model",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "MediaPipe Image Embedder",
+      description: "MediaPipe Image Embedder",
+      capabilities: ["image.embedding"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-models/image_embedder/mobilenet_v3_small/float32/1/mobilenet_v3_small.tflite",
+        task_engine: "vision",
+        pipeline: "vision-image-embedder"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "efficientnet-lite0",
+    label: "EfficientNet Lite0",
+    description: "Image classification model",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "EfficientNet Lite0",
+      description: "Image classification model",
+      capabilities: ["image.classification"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-models/image_classifier/efficientnet_lite0/float32/1/efficientnet_lite0.tflite",
+        task_engine: "vision",
+        pipeline: "vision-image-classifier"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "efficientdet-lite0",
+    label: "Efficient Object Detector Lite0",
+    description: "Object detection model",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "Efficient Object Detector Lite0",
+      description: "Object detection model",
+      capabilities: ["image.object-detection"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-models/object_detector/efficientdet_lite0/float32/1/efficientdet_lite0.tflite",
+        task_engine: "vision",
+        pipeline: "vision-object-detector"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "deeplabv3",
+    label: "Efficient Image Segmenter Lite0",
+    description: "Image segmentation model",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "Efficient Image Segmenter Lite0",
+      description: "Image segmentation model",
+      capabilities: ["image.segmentation"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-assets/deeplabv3.tflite?generation=1661875711618421",
+        task_engine: "vision",
+        pipeline: "vision-image-segmenter"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "face-landmarker",
+    label: "Face Landmarker",
+    description: "Detects 478 facial landmarks with blendshapes",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "Face Landmarker",
+      description: "Detects 478 facial landmarks with blendshapes",
+      capabilities: ["vision.face-landmarks"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task",
+        task_engine: "vision",
+        pipeline: "vision-face-landmarker"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "gesture-recognizer",
+    label: "Gesture Recognizer",
+    description: "Recognizes hand gestures such as thumbs up and victory",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "Gesture Recognizer",
+      description: "Recognizes hand gestures such as thumbs up and victory",
+      capabilities: ["vision.gesture"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-models/gesture_recognizer/gesture_recognizer/float16/1/gesture_recognizer.task",
+        task_engine: "vision",
+        pipeline: "vision-gesture-recognizer"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "hand-landmarker",
+    label: "Hand Landmarker",
+    description: "Detects 21 hand landmarks",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "Hand Landmarker",
+      description: "Detects 21 hand landmarks",
+      capabilities: ["vision.hand-landmarks"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task",
+        task_engine: "vision",
+        pipeline: "vision-hand-landmarker"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  },
+  {
+    id: "pose-landmarker",
+    label: "Pose Landmarker",
+    description: "Detects 33 body pose landmarks",
+    record: {
+      provider: TENSORFLOW_MEDIAPIPE,
+      title: "Pose Landmarker",
+      description: "Detects 33 body pose landmarks",
+      capabilities: ["vision.pose-landmarks"],
+      provider_config: {
+        model_path: "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_lite/float16/1/pose_landmarker_lite.task",
+        task_engine: "vision",
+        pipeline: "vision-pose-landmarker"
+      },
+      metadata: {}
+    },
+    raw: { source: "mediapipe" }
+  }
+];
+function createTFMPModelSearch(providerId) {
+  return async (input, _model, _signal, emit) => {
+    const results = filterModelSearchResultsByQuery(TFMP_MODEL_RESULTS.map((result) => ({
+      ...result,
+      record: { ...result.record, provider: providerId }
+    })), input.query);
+    emit({ type: "finish", data: { results } });
+  };
+}
+var TFMP_ModelSearch = createTFMPModelSearch(TENSORFLOW_MEDIAPIPE);
+
 // src/ai/common/TFMP_ObjectDetection.ts
 import { PermanentJobError as PermanentJobError10 } from "@workglow/job-queue";
-var TFMP_ObjectDetection = async (input, model, onProgress, signal) => {
+var TFMP_ObjectDetection = async (input, model, signal, emit) => {
   const { ObjectDetector } = await loadTfmpTasksVisionSDK();
   const objectDetector = await getModelTask(model, {
     scoreThreshold: input.threshold
-  }, onProgress, signal, ObjectDetector);
+  }, emit, signal, ObjectDetector);
   const result = objectDetector.detect(input.image);
   if (!result.detections) {
     throw new PermanentJobError10("Failed to detect objects: Empty result");
@@ -725,14 +758,12 @@ var TFMP_ObjectDetection = async (input, model, onProgress, signal) => {
       height: detection.boundingBox?.height || 0
     }
   }));
-  return {
-    detections
-  };
+  emit({ type: "finish", data: { detections } });
 };
 
 // src/ai/common/TFMP_PoseLandmarker.ts
 import { PermanentJobError as PermanentJobError11 } from "@workglow/job-queue";
-var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
+var TFMP_PoseLandmarker = async (input, model, signal, emit) => {
   const { PoseLandmarker } = await loadTfmpTasksVisionSDK();
   const poseLandmarker = await getModelTask(model, {
     numPoses: input.numPoses,
@@ -740,7 +771,7 @@ var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
     minPosePresenceConfidence: input.minPosePresenceConfidence,
     minTrackingConfidence: input.minTrackingConfidence,
     outputSegmentationMasks: input.outputSegmentationMasks
-  }, onProgress, signal, PoseLandmarker);
+  }, emit, signal, PoseLandmarker);
   const result = poseLandmarker.detect(input.image);
   if (!result.landmarks) {
     throw new PermanentJobError11("Failed to detect pose landmarks: Empty result");
@@ -772,18 +803,16 @@ var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
     }
     return pose;
   });
-  return {
-    poses
-  };
+  emit({ type: "finish", data: { poses } });
 };
 
 // src/ai/common/TFMP_TextClassification.ts
 import { PermanentJobError as PermanentJobError12 } from "@workglow/job-queue";
-var TFMP_TextClassification = async (input, model, onProgress, signal) => {
+var TFMP_TextClassification = async (input, model, signal, emit) => {
   const { TextClassifier } = await loadTfmpTasksTextSDK();
   const TextClassification = await getModelTask(model, {
     maxCategories: input.maxCategories
-  }, onProgress, signal, TextClassifier);
+  }, emit, signal, TextClassifier);
   const result = TextClassification.classify(input.text);
   if (!result.classifications?.[0]?.categories) {
     throw new PermanentJobError12("Failed to classify text: Empty result");
@@ -792,16 +821,14 @@ var TFMP_TextClassification = async (input, model, onProgress, signal) => {
     label: category.categoryName,
     score: category.score
   }));
-  return {
-    categories
-  };
+  emit({ type: "finish", data: { categories } });
 };
 
 // src/ai/common/TFMP_TextEmbedding.ts
 import { PermanentJobError as PermanentJobError13 } from "@workglow/job-queue";
-var TFMP_TextEmbedding = async (input, model, onProgress, signal) => {
+var TFMP_TextEmbedding = async (input, model, signal, emit) => {
   const { TextEmbedder } = await loadTfmpTasksTextSDK();
-  const textEmbedder = await getModelTask(model, {}, onProgress, signal, TextEmbedder);
+  const textEmbedder = await getModelTask(model, {}, emit, signal, TextEmbedder);
   if (Array.isArray(input.text)) {
     const embeddings = input.text.map((text) => {
       const result2 = textEmbedder.embed(text);
@@ -810,28 +837,25 @@ var TFMP_TextEmbedding = async (input, model, onProgress, signal) => {
       }
       return Float32Array.from(result2.embeddings[0].floatEmbedding);
     });
-    return {
-      vector: embeddings
-    };
+    emit({ type: "finish", data: { vector: embeddings } });
+    return;
   }
   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
-  };
+  emit({ type: "finish", data: { vector: embedding } });
 };
 
 // src/ai/common/TFMP_TextLanguageDetection.ts
 import { PermanentJobError as PermanentJobError14 } from "@workglow/job-queue";
-var TFMP_TextLanguageDetection = async (input, model, onProgress, signal) => {
+var TFMP_TextLanguageDetection = async (input, model, signal, emit) => {
   const maxLanguages = input.maxLanguages === 0 ? -1 : input.maxLanguages;
   const { LanguageDetector } = await loadTfmpTasksTextSDK();
   const textLanguageDetector = await getModelTask(model, {
     maxLanguages
-  }, onProgress, signal, LanguageDetector);
+  }, emit, signal, LanguageDetector);
   const result = textLanguageDetector.detect(input.text);
   if (!result.languages?.[0]?.languageCode) {
     throw new PermanentJobError14("Failed to detect language: Empty result");
@@ -840,15 +864,12 @@ var TFMP_TextLanguageDetection = async (input, model, onProgress, signal) => {
     language: language.languageCode,
     score: language.probability
   }));
-  return {
-    languages
-  };
+  emit({ type: "finish", data: { languages } });
 };
 
 // src/ai/common/TFMP_Unload.ts
-var TFMP_Unload = async (input, model, onProgress, _signal) => {
+var TFMP_Unload = async (input, model, _signal, emit) => {
   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) {
@@ -867,47 +888,108 @@ var TFMP_Unload = async (input, model, onProgress, _signal) => {
     }
     modelTaskCache.delete(model_path);
   }
-  return {
-    model: input.model
-  };
+  emit({ type: "finish", data: { model: input.model } });
 };
 
 // src/ai/common/TFMP_JobRunFns.ts
-var TFMP_TASKS = {
-  DownloadModelTask: TFMP_Download,
-  UnloadModelTask: TFMP_Unload,
-  ModelInfoTask: TFMP_ModelInfo,
-  TextEmbeddingTask: TFMP_TextEmbedding,
-  TextLanguageDetectionTask: TFMP_TextLanguageDetection,
-  TextClassificationTask: TFMP_TextClassification,
-  ImageSegmentationTask: TFMP_ImageSegmentation,
-  ImageEmbeddingTask: TFMP_ImageEmbedding,
-  ImageClassificationTask: TFMP_ImageClassification,
-  ObjectDetectionTask: TFMP_ObjectDetection,
-  GestureRecognizerTask: TFMP_GestureRecognizer,
-  HandLandmarkerTask: TFMP_HandLandmarker,
-  FaceDetectorTask: TFMP_FaceDetector,
-  FaceLandmarkerTask: TFMP_FaceLandmarker,
-  PoseLandmarkerTask: TFMP_PoseLandmarker,
-  ModelSearchTask: TFMP_ModelSearch
-};
+var TFMP_RUN_FNS = [
+  { serves: TFMP_TEXT_EMBEDDING, runFn: TFMP_TextEmbedding },
+  { serves: TFMP_TEXT_CLASSIFICATION, runFn: TFMP_TextClassification },
+  { serves: TFMP_TEXT_LANGUAGE_DETECTION, runFn: TFMP_TextLanguageDetection },
+  { serves: TFMP_IMAGE_CLASSIFICATION, runFn: TFMP_ImageClassification },
+  { serves: TFMP_IMAGE_EMBEDDING, runFn: TFMP_ImageEmbedding },
+  { serves: TFMP_IMAGE_SEGMENTATION, runFn: TFMP_ImageSegmentation },
+  { serves: TFMP_IMAGE_OBJECT_DETECTION, runFn: TFMP_ObjectDetection },
+  { serves: TFMP_VISION_FACE_DETECTION, runFn: TFMP_FaceDetector },
+  { serves: TFMP_VISION_FACE_LANDMARKS, runFn: TFMP_FaceLandmarker },
+  { serves: TFMP_VISION_HAND_LANDMARKS, runFn: TFMP_HandLandmarker },
+  { serves: TFMP_VISION_POSE_LANDMARKS, runFn: TFMP_PoseLandmarker },
+  { serves: TFMP_VISION_GESTURE, runFn: TFMP_GestureRecognizer },
+  { serves: TFMP_MODEL_DOWNLOAD, runFn: TFMP_Download },
+  { serves: TFMP_MODEL_UNLOAD, runFn: TFMP_Unload },
+  { serves: TFMP_MODEL_SEARCH, runFn: TFMP_ModelSearch },
+  { serves: TFMP_MODEL_INFO, runFn: TFMP_ModelInfo }
+];
 
 // src/ai/TensorFlowMediaPipeQueuedProvider.ts
 import { AiProvider } from "@workglow/ai";
+
+// src/ai/common/TFMP_Capabilities.ts
+var TFMP_RUN_FN_SPECS = TFMP_CAPABILITY_SETS.map((serves) => ({ serves }));
+function tfmpWorkerRunFnSpecs() {
+  return TFMP_RUN_FN_SPECS;
+}
+function inferTfmpCapabilities(model) {
+  const declared = model.capabilities ?? [];
+  if (declared.length > 0)
+    return declared;
+  const id = String(model.model_id ?? model.provider_config?.model_path ?? model.provider_config?.model_name ?? "");
+  const baseName = (id.split("/").pop() ?? id).toLowerCase();
+  if (/gesture_recognizer/.test(baseName)) {
+    return [
+      "vision.gesture",
+      "vision.hand-landmarks",
+      "model.download-remove",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/hand_landmarker/.test(baseName)) {
+    return ["vision.hand-landmarks", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/face_landmarker/.test(baseName)) {
+    return ["vision.face-landmarks", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/face_detector|blaze_face/.test(baseName)) {
+    return ["vision.face-detection", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/pose_landmarker/.test(baseName)) {
+    return ["vision.pose-landmarks", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/object_detector|efficientdet|ssd_mobilenet|yolo/.test(baseName)) {
+    return ["image.object-detection", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/segmenter|deeplab|selfie/.test(baseName)) {
+    return ["image.segmentation", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/image_classifier|efficientnet|mobilenet/.test(baseName)) {
+    return ["image.classification", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/image_embed/.test(baseName)) {
+    return ["image.embedding", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/text_embed|universal_sentence_encoder|use_/.test(baseName)) {
+    return ["text.embedding", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/text_classifier|bert_classifier/.test(baseName)) {
+    return ["text.classification", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/language_detector/.test(baseName)) {
+    return ["text.language-detection", "model.download-remove", "model.info", "model.search"];
+  }
+  return ["model.search", "model.info"];
+}
+
+// src/ai/TensorFlowMediaPipeQueuedProvider.ts
 class TensorFlowMediaPipeQueuedProvider extends AiProvider {
   name = TENSORFLOW_MEDIAPIPE;
   displayName = "TensorFlow MediaPipe";
   isLocal = true;
   supportsBrowser = true;
-  taskTypes = TFMP_DEFAULT_TASK_TYPES;
-  constructor(tasks, previewTasks) {
-    super(tasks, undefined, previewTasks);
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferTfmpCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return tfmpWorkerRunFnSpecs();
   }
 }
 
 // src/ai/registerTensorFlowMediaPipeInline.ts
 async function registerTensorFlowMediaPipeInline(options) {
-  await registerProviderInline(new TensorFlowMediaPipeQueuedProvider(TFMP_TASKS), "TensorFlow MediaPipe", options);
+  await registerProviderInline(new TensorFlowMediaPipeQueuedProvider(TFMP_RUN_FNS), "TensorFlow MediaPipe", options);
 }
 
 // src/ai/registerTensorFlowMediaPipeWorker.ts
@@ -920,15 +1002,20 @@ class TensorFlowMediaPipeProvider extends AiProvider2 {
   displayName = "TensorFlow MediaPipe";
   isLocal = true;
   supportsBrowser = true;
-  taskTypes = TFMP_DEFAULT_TASK_TYPES;
-  constructor(tasks, previewTasks) {
-    super(tasks, undefined, previewTasks);
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferTfmpCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return tfmpWorkerRunFnSpecs();
   }
 }
 
 // src/ai/registerTensorFlowMediaPipeWorker.ts
 async function registerTensorFlowMediaPipeWorker() {
-  await registerProviderWorker((ws) => new TensorFlowMediaPipeProvider(TFMP_TASKS).registerOnWorkerServer(ws), "TensorFlow MediaPipe");
+  await registerProviderWorker((ws) => new TensorFlowMediaPipeProvider(TFMP_RUN_FNS).registerOnWorkerServer(ws), "TensorFlow MediaPipe");
 }
 export {
   registerTensorFlowMediaPipeWorker,
@@ -937,4 +1024,4 @@ export {
   loadTfmpTasksTextSDK
 };
 
-//# debugId=CB3FDA3C7C718E4C64756E2164756E21
+//# debugId=271A8EDB1D7FB3E564756E2164756E21