@workglow/tf-mediapipe 0.2.28

package/dist/ai-provider-runtime.js

@@ -0,0 +1,761 @@
+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/ai-provider/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/ai-provider/registerTensorFlowMediaPipeInline.ts
+import { registerProviderInline } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/TFMP_ModelSearch.ts
+import { filterLabeledModelsByQuery } from "@workglow/ai-provider/common";
+
+// src/ai-provider/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",
+  "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-provider/common/TFMP_ModelSearch.ts
+var TFMP_MODELS = [
+  { label: "text-embedder  Universal Sentence Encoder", value: "text-embedder" }
+];
+function createTFMPModelSearch(providerId) {
+  return async (input) => {
+    const models = filterLabeledModelsByQuery(TFMP_MODELS, input.query);
+    const results = 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/ai-provider/common/TFMP_Download.ts
+import { PermanentJobError as PermanentJobError2 } from "@workglow/job-queue";
+
+// src/ai-provider/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)) {
+    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 "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": {
+      const { FilesetResolver } = await loadTfmpTasksTextSDK();
+      wasmFileset = await FilesetResolver.forAudioTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-audio@latest/wasm");
+      break;
+    }
+    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 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
+    },
+    ...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;
+};
+
+// src/ai-provider/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 loadTfmpTasksTextSDK();
+      task = await getModelTask(model, {}, onProgress, signal, TextEmbedder);
+      break;
+    }
+    case "text-classifier": {
+      const { TextClassifier } = await loadTfmpTasksTextSDK();
+      task = await getModelTask(model, {}, onProgress, signal, TextClassifier);
+      break;
+    }
+    case "text-language-detector": {
+      const { LanguageDetector } = await loadTfmpTasksTextSDK();
+      task = await getModelTask(model, {}, onProgress, signal, LanguageDetector);
+      break;
+    }
+    case "vision-image-classifier": {
+      const { ImageClassifier } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, ImageClassifier);
+      break;
+    }
+    case "vision-image-embedder": {
+      const { ImageEmbedder } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
+      break;
+    }
+    case "vision-image-segmenter": {
+      const { ImageSegmenter } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
+      break;
+    }
+    case "vision-object-detector": {
+      const { ObjectDetector } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, ObjectDetector);
+      break;
+    }
+    case "vision-face-detector": {
+      const { FaceDetector } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, FaceDetector);
+      break;
+    }
+    case "vision-face-landmarker": {
+      const { FaceLandmarker } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, FaceLandmarker);
+      break;
+    }
+    case "vision-gesture-recognizer": {
+      const { GestureRecognizer } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, GestureRecognizer);
+      break;
+    }
+    case "vision-hand-landmarker": {
+      const { HandLandmarker } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, HandLandmarker);
+      break;
+    }
+    case "vision-pose-landmarker": {
+      const { PoseLandmarker } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, onProgress, 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`);
+  }
+  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
+  };
+};
+
+// src/ai-provider/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 PermanentJobError3("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
+    },
+    keypoints: detection.keypoints?.map((kp) => ({
+      x: kp.x,
+      y: kp.y,
+      label: kp.label
+    })) || [],
+    score: detection.categories?.[0]?.score || 0
+  }));
+  return {
+    faces
+  };
+};
+
+// src/ai-provider/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/ai-provider/common/TFMP_GestureRecognizer.ts
+import { PermanentJobError as PermanentJobError5 } from "@workglow/job-queue";
+var TFMP_GestureRecognizer = async (input, model, onProgress, signal) => {
+  const { GestureRecognizer } = await loadTfmpTasksVisionSDK();
+  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 PermanentJobError5("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
+  };
+};
+
+// src/ai-provider/common/TFMP_HandLandmarker.ts
+import { PermanentJobError as PermanentJobError6 } from "@workglow/job-queue";
+var TFMP_HandLandmarker = async (input, model, onProgress, signal) => {
+  const { HandLandmarker } = await loadTfmpTasksVisionSDK();
+  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 PermanentJobError6("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
+  };
+};
+
+// src/ai-provider/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 categories = result.classifications[0].categories.map((category) => ({
+    label: category.categoryName,
+    score: category.score
+  }));
+  return {
+    categories
+  };
+};
+
+// src/ai-provider/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);
+  if (Array.isArray(input.image)) {
+    const vectors = [];
+    for (const image of input.image) {
+      const result2 = imageEmbedder.embed(image);
+      if (!result2.embeddings?.[0]?.floatEmbedding) {
+        throw new PermanentJobError8("Failed to generate embedding: Empty result");
+      }
+      vectors.push(Float32Array.from(result2.embeddings[0].floatEmbedding));
+    }
+    return { vector: vectors };
+  }
+  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
+  };
+};
+
+// src/ai-provider/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
+      }
+    }
+  ];
+  return {
+    masks
+  };
+};
+
+// src/ai-provider/common/TFMP_ModelInfo.ts
+var TFMP_EMBEDDING_DIMENSIONS = {
+  "universal-sentence-encoder": { native_dimensions: 512, mrl: false }
+};
+var TFMP_ModelInfo = async (input, model) => {
+  if (input.detail === "dimensions") {
+    const pc = model?.provider_config;
+    let native_dimensions = typeof pc?.native_dimensions === "number" ? pc.native_dimensions : undefined;
+    const mrl = typeof pc?.mrl === "boolean" ? pc.mrl : false;
+    if (native_dimensions === undefined) {
+      const modelPath = pc?.model_path ?? "";
+      const known = TFMP_EMBEDDING_DIMENSIONS[modelPath];
+      if (known) {
+        native_dimensions = known.native_dimensions;
+      }
+    }
+    return {
+      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
+  };
+};
+
+// src/ai-provider/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 {
+    detections
+  };
+};
+
+// src/ai-provider/common/TFMP_PoseLandmarker.ts
+import { PermanentJobError as PermanentJobError11 } from "@workglow/job-queue";
+var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
+  const { PoseLandmarker } = await loadTfmpTasksVisionSDK();
+  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 PermanentJobError11("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
+  };
+};
+
+// src/ai-provider/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/ai-provider/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/ai-provider/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/ai-provider/common/TFMP_Unload.ts
+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
+  };
+};
+
+// src/ai-provider/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
+};
+
+// src/ai-provider/TensorFlowMediaPipeQueuedProvider.ts
+import { AiProvider } from "@workglow/ai";
+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);
+  }
+}
+
+// src/ai-provider/registerTensorFlowMediaPipeInline.ts
+async function registerTensorFlowMediaPipeInline(options) {
+  await registerProviderInline(new TensorFlowMediaPipeQueuedProvider(TFMP_TASKS), "TensorFlow MediaPipe", options);
+}
+
+// src/ai-provider/registerTensorFlowMediaPipeWorker.ts
+import { registerProviderWorker } from "@workglow/ai-provider/common";
+
+// src/ai-provider/TensorFlowMediaPipeProvider.ts
+import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
+class TensorFlowMediaPipeProvider extends AiProvider2 {
+  name = TENSORFLOW_MEDIAPIPE;
+  displayName = "TensorFlow MediaPipe";
+  isLocal = true;
+  supportsBrowser = true;
+  taskTypes = TFMP_DEFAULT_TASK_TYPES;
+  constructor(tasks, previewTasks) {
+    super(tasks, undefined, previewTasks);
+  }
+}
+
+// src/ai-provider/registerTensorFlowMediaPipeWorker.ts
+async function registerTensorFlowMediaPipeWorker() {
+  await registerProviderWorker((ws) => new TensorFlowMediaPipeProvider(TFMP_TASKS).registerOnWorkerServer(ws), "TensorFlow MediaPipe");
+}
+export {
+  registerTensorFlowMediaPipeWorker,
+  registerTensorFlowMediaPipeInline,
+  loadTfmpTasksVisionSDK,
+  loadTfmpTasksTextSDK
+};
+
+//# debugId=C2FBE955556A6BD164756E2164756E21