@workglow/ai 0.0.71 → 0.0.73

package/dist/node.js

@@ -446,125 +446,9 @@ class DocumentConverterText extends DocumentConverter {
     return new Document(this.text, this.metadata);
   }
 }
-// src/task/base/AiTask.ts
-import {
-  JobQueueTask,
-  TaskConfigurationError
-} from "@workglow/task-graph";
-function schemaFormat(schema) {
-  return typeof schema === "object" && schema !== null && "format" in schema ? schema.format : undefined;
-}
+// src/task/BackgroundRemovalTask.ts
+import { CreateWorkflow, TaskRegistry, Workflow } from "@workglow/task-graph";
 
-class AiTask extends JobQueueTask {
-  static type = "AiTask";
-  modelCache;
-  constructor(input = {}, config = {}) {
-    config.name ||= `${new.target.type || new.target.name}${input.model ? " with model " + input.model : ""}`;
-    super(input, config);
-  }
-  async getJobInput(input) {
-    if (typeof input.model !== "string") {
-      console.error("AiTask: Model is not a string", input);
-      throw new TaskConfigurationError("AiTask: Model is not a string, only create job for single model tasks");
-    }
-    const runtype = this.constructor.runtype ?? this.constructor.type;
-    const model = await this.getModelForInput(input);
-    return {
-      taskType: runtype,
-      aiProvider: model.provider,
-      taskInput: input
-    };
-  }
-  async createJob(input, queueName) {
-    const jobInput = await this.getJobInput(input);
-    const resolvedQueueName = queueName ?? await this.getDefaultQueueName(input);
-    if (!resolvedQueueName) {
-      throw new TaskConfigurationError("JobQueueTask: Unable to determine queue for AI provider");
-    }
-    const job = new AiJob({
-      queueName: resolvedQueueName,
-      jobRunId: this.config.runnerId,
-      input: jobInput
-    });
-    return job;
-  }
-  async getModelForInput(input) {
-    const modelname = input.model;
-    if (!modelname)
-      throw new TaskConfigurationError("AiTask: No model name found");
-    if (this.modelCache && this.modelCache.name === modelname) {
-      return this.modelCache.model;
-    }
-    const model = await getGlobalModelRepository().findByName(modelname);
-    if (!model) {
-      throw new TaskConfigurationError(`JobQueueTask: No model ${modelname} found`);
-    }
-    this.modelCache = { name: modelname, model };
-    return model;
-  }
-  async getDefaultQueueName(input) {
-    if (typeof input.model === "string") {
-      const model = await this.getModelForInput(input);
-      return model.provider;
-    }
-    return;
-  }
-  async validateInput(input) {
-    const inputSchema = this.inputSchema();
-    if (typeof inputSchema === "boolean") {
-      if (inputSchema === false) {
-        throw new TaskConfigurationError(`AiTask: Input schema is 'false' and accepts no inputs`);
-      }
-      return true;
-    }
-    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
-    if (modelTaskProperties.length > 0) {
-      const taskModels = await getGlobalModelRepository().findModelsByTask(this.type);
-      for (const [key, propSchema] of modelTaskProperties) {
-        let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
-        for (const model of requestedModels) {
-          const foundModel = taskModels?.find((m) => m.model_id === model);
-          if (!foundModel) {
-            throw new TaskConfigurationError(`AiTask: Missing model for '${key}' named '${model}' for task '${this.type}'`);
-          }
-        }
-      }
-    }
-    const modelPlainProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema) === "model");
-    if (modelPlainProperties.length > 0) {
-      for (const [key, propSchema] of modelPlainProperties) {
-        let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
-        for (const model of requestedModels) {
-          const foundModel = await getGlobalModelRepository().findByName(model);
-          if (!foundModel) {
-            throw new TaskConfigurationError(`AiTask: Missing model for "${key}" named "${model}"`);
-          }
-        }
-      }
-    }
-    return super.validateInput(input);
-  }
-  async narrowInput(input) {
-    const inputSchema = this.inputSchema();
-    if (typeof inputSchema === "boolean") {
-      if (inputSchema === false) {
-        throw new TaskConfigurationError(`AiTask: Input schema is 'false' and accepts no inputs`);
-      }
-      return input;
-    }
-    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
-    if (modelTaskProperties.length > 0) {
-      const taskModels = await getGlobalModelRepository().findModelsByTask(this.type);
-      for (const [key, propSchema] of modelTaskProperties) {
-        let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
-        let usingModels = requestedModels.filter((model) => taskModels?.find((m) => m.model_id === model));
-        usingModels = usingModels.length > 1 ? usingModels : usingModels[0];
-        input[key] = usingModels;
-      }
-    }
-    return input;
-  }
-}
 // src/task/base/AiTaskSchemas.ts
 import {
   FromSchemaDefaultOptions
@@ -692,134 +576,1541 @@ var TypeReplicateArray = (type, annotations = {}) => ({
   ...annotations,
   "x-replicate": true
 });
-// src/task/DocumentSplitterTask.ts
+var TypeImageInput = {
+  oneOf: [
+    {
+      type: "string",
+      title: "Image Data",
+      description: "Image as data-uri"
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        data: {
+          oneOf: [
+            {
+              type: "object",
+              format: "image:ImageBitmap",
+              title: "ImageBitmap"
+            },
+            {
+              type: "object",
+              format: "image:OffscreenCanvas",
+              title: "OffscreenCanvas"
+            },
+            {
+              type: "object",
+              format: "image:VideoFrame",
+              title: "VideoFrame"
+            },
+            {
+              type: "object",
+              properties: {
+                data: {
+                  type: "array",
+                  items: { type: "number", format: "Uint8Clamped" },
+                  format: "Uint8ClampedArray",
+                  title: "Data",
+                  description: "Data of the image"
+                },
+                width: { type: "number", title: "Width", description: "Width of the image" },
+                height: { type: "number", title: "Height", description: "Height of the image" },
+                channels: {
+                  type: "number",
+                  title: "Channels",
+                  description: "Channels of the image"
+                },
+                rawChannels: {
+                  type: "number",
+                  title: "Raw Channels",
+                  description: "Raw channels of the image"
+                }
+              },
+              additionalProperties: false,
+              required: ["data", "width", "height", "channels"],
+              format: "image:ImageBinary",
+              title: "ImageBinary"
+            }
+          ]
+        },
+        width: { type: "number", title: "Width", description: "Width of the image" },
+        height: { type: "number", title: "Height", description: "Height of the image" },
+        channels: {
+          type: "number",
+          title: "Channels",
+          description: "Channels of the image",
+          minimum: 1,
+          maximum: 4
+        }
+      },
+      required: ["data", "width", "height", "channels"]
+    }
+  ],
+  title: "Image",
+  description: "Image as URL or base64-encoded data"
+};
+var TypeAudioInput = {
+  type: "string",
+  title: "Audio",
+  description: "Audio as data-uri, or Blob"
+};
+var TypeBoundingBox = {
+  type: "object",
+  properties: {
+    x: { type: "number", title: "X coordinate", description: "Left edge of the bounding box" },
+    y: { type: "number", title: "Y coordinate", description: "Top edge of the bounding box" },
+    width: { type: "number", title: "Width", description: "Width of the bounding box" },
+    height: { type: "number", title: "Height", description: "Height of the bounding box" }
+  },
+  required: ["x", "y", "width", "height"],
+  additionalProperties: false,
+  title: "Bounding Box",
+  description: "Bounding box coordinates"
+};
+var TypeCategory = {
+  type: "object",
+  properties: {
+    label: { type: "string", title: "Label", description: "Category label" },
+    score: {
+      type: "number",
+      title: "Confidence Score",
+      description: "Confidence score between 0 and 1",
+      minimum: 0,
+      maximum: 1
+    }
+  },
+  required: ["label", "score"],
+  additionalProperties: false,
+  title: "Category",
+  description: "Classification category with label and score"
+};
+
+// src/task/base/AiVisionTask.ts
+import { convertImageDataToUseableForm } from "@workglow/util";
+
+// src/task/base/AiTask.ts
 import {
-  CreateWorkflow,
-  Task,
-  TaskRegistry,
-  Workflow
+  JobQueueTask,
+  TaskConfigurationError
 } from "@workglow/task-graph";
-var inputSchema = {
+function schemaFormat(schema) {
+  return typeof schema === "object" && schema !== null && "format" in schema ? schema.format : undefined;
+}
+
+class AiTask extends JobQueueTask {
+  static type = "AiTask";
+  modelCache;
+  constructor(input = {}, config = {}) {
+    config.name ||= `${new.target.type || new.target.name}${input.model ? " with model " + input.model : ""}`;
+    super(input, config);
+  }
+  async getJobInput(input) {
+    if (typeof input.model !== "string") {
+      console.error("AiTask: Model is not a string", input);
+      throw new TaskConfigurationError("AiTask: Model is not a string, only create job for single model tasks");
+    }
+    const runtype = this.constructor.runtype ?? this.constructor.type;
+    const model = await this.getModelForInput(input);
+    return {
+      taskType: runtype,
+      aiProvider: model.provider,
+      taskInput: input
+    };
+  }
+  async createJob(input, queueName) {
+    const jobInput = await this.getJobInput(input);
+    const resolvedQueueName = queueName ?? await this.getDefaultQueueName(input);
+    if (!resolvedQueueName) {
+      throw new TaskConfigurationError("JobQueueTask: Unable to determine queue for AI provider");
+    }
+    const job = new AiJob({
+      queueName: resolvedQueueName,
+      jobRunId: this.config.runnerId,
+      input: jobInput
+    });
+    return job;
+  }
+  async getModelForInput(input) {
+    const modelname = input.model;
+    if (!modelname)
+      throw new TaskConfigurationError("AiTask: No model name found");
+    if (this.modelCache && this.modelCache.name === modelname) {
+      return this.modelCache.model;
+    }
+    const model = await getGlobalModelRepository().findByName(modelname);
+    if (!model) {
+      throw new TaskConfigurationError(`JobQueueTask: No model ${modelname} found`);
+    }
+    this.modelCache = { name: modelname, model };
+    return model;
+  }
+  async getDefaultQueueName(input) {
+    if (typeof input.model === "string") {
+      const model = await this.getModelForInput(input);
+      return model.provider;
+    }
+    return;
+  }
+  async validateInput(input) {
+    const inputSchema = this.inputSchema();
+    if (typeof inputSchema === "boolean") {
+      if (inputSchema === false) {
+        throw new TaskConfigurationError(`AiTask: Input schema is 'false' and accepts no inputs`);
+      }
+      return true;
+    }
+    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
+    if (modelTaskProperties.length > 0) {
+      const taskModels = await getGlobalModelRepository().findModelsByTask(this.type);
+      for (const [key, propSchema] of modelTaskProperties) {
+        let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
+        for (const model of requestedModels) {
+          const foundModel = taskModels?.find((m) => m.model_id === model);
+          if (!foundModel) {
+            throw new TaskConfigurationError(`AiTask: Missing model for '${key}' named '${model}' for task '${this.type}'`);
+          }
+        }
+      }
+    }
+    const modelPlainProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema) === "model");
+    if (modelPlainProperties.length > 0) {
+      for (const [key, propSchema] of modelPlainProperties) {
+        let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
+        for (const model of requestedModels) {
+          const foundModel = await getGlobalModelRepository().findByName(model);
+          if (!foundModel) {
+            throw new TaskConfigurationError(`AiTask: Missing model for "${key}" named "${model}"`);
+          }
+        }
+      }
+    }
+    return super.validateInput(input);
+  }
+  async narrowInput(input) {
+    const inputSchema = this.inputSchema();
+    if (typeof inputSchema === "boolean") {
+      if (inputSchema === false) {
+        throw new TaskConfigurationError(`AiTask: Input schema is 'false' and accepts no inputs`);
+      }
+      return input;
+    }
+    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
+    if (modelTaskProperties.length > 0) {
+      const taskModels = await getGlobalModelRepository().findModelsByTask(this.type);
+      for (const [key, propSchema] of modelTaskProperties) {
+        let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
+        let usingModels = requestedModels.filter((model) => taskModels?.find((m) => m.model_id === model));
+        usingModels = usingModels.length > 1 ? usingModels : usingModels[0];
+        input[key] = usingModels;
+      }
+    }
+    return input;
+  }
+}
+
+// src/task/base/AiVisionTask.ts
+class AiVisionTask extends AiTask {
+  static type = "AiVisionTask";
+  async getJobInput(input) {
+    const jobInput = await super.getJobInput(input);
+    const registeredQueue = await this.resolveQueue(input);
+    const queueName = registeredQueue?.server.queueName;
+    const supports = ["Blob"];
+    if (input.image) {
+      if ("OffscreenCanvas" in globalThis) {
+        supports.push("OffscreenCanvas");
+      } else if (queueName === "TENSORFLOW_MEDIAPIPE" && "ImageBitmap" in globalThis) {
+        supports.push("ImageBitmap");
+      } else if (queueName === "TENSORFLOW_MEDIAPIPE" && "VideoFrame" in globalThis) {
+        supports.push("VideoFrame");
+      }
+      const image = await convertImageDataToUseableForm(input.image, supports);
+      jobInput.taskInput.image = image;
+    }
+    return jobInput;
+  }
+}
+
+// src/task/BackgroundRemovalTask.ts
+var modelSchema = TypeReplicateArray(TypeModel("model:BackgroundRemovalTask"));
+var processedImageSchema = {
+  type: "string",
+  contentEncoding: "base64",
+  contentMediaType: "image/png",
+  title: "Image",
+  description: "Base64-encoded PNG image with transparent background"
+};
+var BackgroundRemovalInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var BackgroundRemovalOutputSchema = {
+  type: "object",
+  properties: {
+    image: {
+      oneOf: [processedImageSchema, { type: "array", items: processedImageSchema }],
+      title: processedImageSchema.title,
+      description: processedImageSchema.description
+    }
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+class BackgroundRemovalTask extends AiVisionTask {
+  static type = "BackgroundRemovalTask";
+  static category = "AI Vision Model";
+  static title = "Background Removal";
+  static description = "Removes backgrounds from images, producing images with transparent backgrounds";
+  static inputSchema() {
+    return BackgroundRemovalInputSchema;
+  }
+  static outputSchema() {
+    return BackgroundRemovalOutputSchema;
+  }
+}
+TaskRegistry.registerTask(BackgroundRemovalTask);
+var BackgroundRemoval = (input, config) => {
+  return new BackgroundRemovalTask(input, config).run();
+};
+Workflow.prototype.BackgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
+// src/task/DocumentSplitterTask.ts
+import {
+  CreateWorkflow as CreateWorkflow2,
+  Task,
+  TaskRegistry as TaskRegistry2,
+  Workflow as Workflow2
+} from "@workglow/task-graph";
+var inputSchema = {
+  type: "object",
+  properties: {
+    parser: {
+      type: "string",
+      enum: ["txt", "md"],
+      title: "Document Kind",
+      description: "The kind of document (txt or md)"
+    }
+  },
+  required: ["parser"],
+  additionalProperties: false
+};
+var outputSchema = {
+  type: "object",
+  properties: {
+    texts: {
+      type: "array",
+      items: { type: "string" },
+      title: "Text Chunks",
+      description: "The text chunks of the document"
+    }
+  },
+  required: ["texts"],
+  additionalProperties: false
+};
+
+class DocumentSplitterTask extends Task {
+  static type = "DocumentSplitterTask";
+  static category = "Document";
+  static title = "Document Splitter";
+  static description = "Splits documents into text chunks for processing";
+  static inputSchema() {
+    return inputSchema;
+  }
+  static outputSchema() {
+    return outputSchema;
+  }
+  flattenFragmentsToTexts(item) {
+    if (item instanceof Document) {
+      const texts = [];
+      item.fragments.forEach((fragment) => {
+        texts.push(...this.flattenFragmentsToTexts(fragment));
+      });
+      return texts;
+    } else {
+      return [item.content];
+    }
+  }
+  async executeReactive() {
+    return { texts: this.flattenFragmentsToTexts(this.runInputData.file) };
+  }
+}
+TaskRegistry2.registerTask(DocumentSplitterTask);
+var DocumentSplitter = (input) => {
+  return new DocumentSplitterTask(input).run();
+};
+Workflow2.prototype.DocumentSplitter = CreateWorkflow2(DocumentSplitterTask);
+// src/task/DownloadModelTask.ts
+import { CreateWorkflow as CreateWorkflow3, TaskRegistry as TaskRegistry3, Workflow as Workflow3 } from "@workglow/task-graph";
+var modelSchema2 = TypeReplicateArray(TypeModel("model"));
+var DownloadModelInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema2
+  },
+  required: ["model"],
+  additionalProperties: false
+};
+var DownloadModelOutputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema2
+  },
+  required: ["model"],
+  additionalProperties: false
+};
+
+class DownloadModelTask extends AiTask {
+  static type = "DownloadModelTask";
+  static category = "AI Text Model";
+  static title = "Download Model";
+  static description = "Downloads and caches AI models locally with progress tracking";
+  static inputSchema() {
+    return DownloadModelInputSchema;
+  }
+  static outputSchema() {
+    return DownloadModelOutputSchema;
+  }
+  static cacheable = false;
+  files = [];
+  constructor(input, config = {}) {
+    super(input, config);
+    this.on("progress", this.processProgress.bind(this));
+    this.on("start", () => {
+      this.files = [];
+    });
+  }
+  processProgress(progress, message = "", details) {
+    if (details?.file) {
+      const file = this.files.find((f) => f.file === details.file);
+      if (file) {
+        file.progress = details.progress;
+      } else {
+        this.files.push({ file: details.file, progress: details.progress });
+      }
+      this.progress = this.files.reduce((acc, f) => acc + f.progress, 0) / this.files.length;
+    } else {
+      this.progress = progress;
+    }
+  }
+}
+TaskRegistry3.registerTask(DownloadModelTask);
+var DownloadModel = (input, config) => {
+  return new DownloadModelTask(input, config).run();
+};
+Workflow3.prototype.DownloadModel = CreateWorkflow3(DownloadModelTask);
+// src/task/FaceDetectorTask.ts
+import { CreateWorkflow as CreateWorkflow4, TaskRegistry as TaskRegistry4, Workflow as Workflow4 } from "@workglow/task-graph";
+var modelSchema3 = TypeReplicateArray(TypeModel("model:FaceDetectorTask"));
+var TypeBoundingBox2 = {
+  type: "object",
+  properties: {
+    x: {
+      type: "number",
+      title: "X Coordinate",
+      description: "X coordinate of the top-left corner"
+    },
+    y: {
+      type: "number",
+      title: "Y Coordinate",
+      description: "Y coordinate of the top-left corner"
+    },
+    width: {
+      type: "number",
+      title: "Width",
+      description: "Width of the bounding box"
+    },
+    height: {
+      type: "number",
+      title: "Height",
+      description: "Height of the bounding box"
+    }
+  },
+  required: ["x", "y", "width", "height"],
+  additionalProperties: false
+};
+var TypeKeypoint = {
+  type: "object",
+  properties: {
+    x: {
+      type: "number",
+      title: "X Coordinate",
+      description: "X coordinate normalized to [0.0, 1.0]"
+    },
+    y: {
+      type: "number",
+      title: "Y Coordinate",
+      description: "Y coordinate normalized to [0.0, 1.0]"
+    },
+    label: {
+      type: "string",
+      title: "Keypoint Label",
+      description: "Label for the keypoint (e.g., 'leftEye', 'rightEye', 'noseTip', etc.)"
+    }
+  },
+  required: ["x", "y"],
+  additionalProperties: false
+};
+var TypeFaceDetection = {
+  type: "object",
+  properties: {
+    box: TypeBoundingBox2,
+    keypoints: {
+      type: "array",
+      items: TypeKeypoint,
+      title: "Keypoints",
+      description: "Facial keypoints (left eye, right eye, nose tip, mouth, left/right tragion)"
+    },
+    score: {
+      type: "number",
+      title: "Confidence Score",
+      description: "Confidence score for the face detection"
+    }
+  },
+  required: ["box", "keypoints", "score"],
+  additionalProperties: false
+};
+var FaceDetectorInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema3,
+    minDetectionConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Detection Confidence",
+      description: "Minimum confidence score for face detection",
+      "x-ui-group": "Configuration"
+    },
+    minSuppressionThreshold: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.3,
+      title: "Min Suppression Threshold",
+      description: "Minimum non-maximum-suppression threshold for overlapping detections",
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var FaceDetectorOutputSchema = {
+  type: "object",
+  properties: {
+    faces: {
+      oneOf: [
+        { type: "array", items: TypeFaceDetection },
+        { type: "array", items: { type: "array", items: TypeFaceDetection } }
+      ],
+      title: "Face Detections",
+      description: "Detected faces with bounding boxes, keypoints, and confidence scores"
+    }
+  },
+  required: ["faces"],
+  additionalProperties: false
+};
+
+class FaceDetectorTask extends AiVisionTask {
+  static type = "FaceDetectorTask";
+  static category = "AI Vision Model";
+  static title = "Face Detector";
+  static description = "Detects faces in images. Locates faces and identifies facial keypoints like eyes, nose, and mouth.";
+  static inputSchema() {
+    return FaceDetectorInputSchema;
+  }
+  static outputSchema() {
+    return FaceDetectorOutputSchema;
+  }
+}
+TaskRegistry4.registerTask(FaceDetectorTask);
+var FaceDetector = (input, config) => {
+  return new FaceDetectorTask(input, config).run();
+};
+Workflow4.prototype.FaceDetector = CreateWorkflow4(FaceDetectorTask);
+// src/task/FaceLandmarkerTask.ts
+import { CreateWorkflow as CreateWorkflow5, TaskRegistry as TaskRegistry5, Workflow as Workflow5 } from "@workglow/task-graph";
+var modelSchema4 = TypeReplicateArray(TypeModel("model:FaceLandmarkerTask"));
+var TypeLandmark = {
+  type: "object",
+  properties: {
+    x: {
+      type: "number",
+      title: "X Coordinate",
+      description: "X coordinate normalized to [0.0, 1.0]"
+    },
+    y: {
+      type: "number",
+      title: "Y Coordinate",
+      description: "Y coordinate normalized to [0.0, 1.0]"
+    },
+    z: {
+      type: "number",
+      title: "Z Coordinate",
+      description: "Z coordinate (depth)"
+    }
+  },
+  required: ["x", "y", "z"],
+  additionalProperties: false
+};
+var TypeBlendshape = {
+  type: "object",
+  properties: {
+    label: {
+      type: "string",
+      title: "Blendshape Label",
+      description: "Name of the blendshape (e.g., 'browDownLeft', 'eyeBlinkRight', etc.)"
+    },
+    score: {
+      type: "number",
+      title: "Coefficient Value",
+      description: "Coefficient value for this blendshape"
+    }
+  },
+  required: ["label", "score"],
+  additionalProperties: false
+};
+var TypeTransformationMatrix = {
+  type: "array",
+  items: { type: "number" },
+  minItems: 16,
+  maxItems: 16,
+  title: "Transformation Matrix",
+  description: "4x4 transformation matrix for face effects rendering"
+};
+var TypeFaceLandmarkerDetection = {
+  type: "object",
+  properties: {
+    landmarks: {
+      type: "array",
+      items: TypeLandmark,
+      title: "Landmarks",
+      description: "478 facial landmarks in image coordinates"
+    },
+    blendshapes: {
+      type: "array",
+      items: TypeBlendshape,
+      title: "Blendshapes",
+      description: "52 blendshape coefficients representing facial expressions"
+    },
+    transformationMatrix: TypeTransformationMatrix
+  },
+  required: ["landmarks"],
+  additionalProperties: false
+};
+var FaceLandmarkerInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema4,
+    numFaces: {
+      type: "number",
+      minimum: 1,
+      maximum: 10,
+      default: 1,
+      title: "Number of Faces",
+      description: "The maximum number of faces to detect",
+      "x-ui-group": "Configuration"
+    },
+    minFaceDetectionConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Face Detection Confidence",
+      description: "Minimum confidence score for face detection",
+      "x-ui-group": "Configuration"
+    },
+    minFacePresenceConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Face Presence Confidence",
+      description: "Minimum confidence score for face presence",
+      "x-ui-group": "Configuration"
+    },
+    minTrackingConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Tracking Confidence",
+      description: "Minimum confidence score for face tracking",
+      "x-ui-group": "Configuration"
+    },
+    outputFaceBlendshapes: {
+      type: "boolean",
+      default: false,
+      title: "Output Face Blendshapes",
+      description: "Whether to output blendshape coefficients for facial expressions",
+      "x-ui-group": "Configuration"
+    },
+    outputFacialTransformationMatrixes: {
+      type: "boolean",
+      default: false,
+      title: "Output Facial Transformation Matrix",
+      description: "Whether to output transformation matrix for effects rendering",
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var FaceLandmarkerOutputSchema = {
+  type: "object",
+  properties: {
+    faces: {
+      oneOf: [
+        { type: "array", items: TypeFaceLandmarkerDetection },
+        { type: "array", items: { type: "array", items: TypeFaceLandmarkerDetection } }
+      ],
+      title: "Face Detections",
+      description: "Detected faces with landmarks, blendshapes, and transformation matrices"
+    }
+  },
+  required: ["faces"],
+  additionalProperties: false
+};
+
+class FaceLandmarkerTask extends AiVisionTask {
+  static type = "FaceLandmarkerTask";
+  static category = "AI Vision Model";
+  static title = "Face Landmarker";
+  static description = "Detects facial landmarks and expressions in images. Identifies 478 facial landmarks, blendshapes for expressions, and transformation matrices for AR effects.";
+  static inputSchema() {
+    return FaceLandmarkerInputSchema;
+  }
+  static outputSchema() {
+    return FaceLandmarkerOutputSchema;
+  }
+}
+TaskRegistry5.registerTask(FaceLandmarkerTask);
+var FaceLandmarker = (input, config) => {
+  return new FaceLandmarkerTask(input, config).run();
+};
+Workflow5.prototype.FaceLandmarker = CreateWorkflow5(FaceLandmarkerTask);
+// src/task/GestureRecognizerTask.ts
+import { CreateWorkflow as CreateWorkflow6, TaskRegistry as TaskRegistry6, Workflow as Workflow6 } from "@workglow/task-graph";
+var modelSchema5 = TypeReplicateArray(TypeModel("model:GestureRecognizerTask"));
+var TypeLandmark2 = {
+  type: "object",
+  properties: {
+    x: {
+      type: "number",
+      title: "X Coordinate",
+      description: "X coordinate normalized to [0.0, 1.0]"
+    },
+    y: {
+      type: "number",
+      title: "Y Coordinate",
+      description: "Y coordinate normalized to [0.0, 1.0]"
+    },
+    z: {
+      type: "number",
+      title: "Z Coordinate",
+      description: "Z coordinate (depth)"
+    }
+  },
+  required: ["x", "y", "z"],
+  additionalProperties: false
+};
+var TypeGesture = {
+  type: "object",
+  properties: {
+    label: {
+      type: "string",
+      title: "Gesture Label",
+      description: "The recognized gesture (e.g., 'Thumb_Up', 'Victory', etc.)"
+    },
+    score: {
+      type: "number",
+      title: "Confidence Score",
+      description: "Confidence score for the gesture"
+    }
+  },
+  required: ["label", "score"],
+  additionalProperties: false
+};
+var TypeHandedness = {
+  type: "object",
+  properties: {
+    label: {
+      type: "string",
+      title: "Hand Label",
+      description: "Whether the hand is 'Left' or 'Right'"
+    },
+    score: {
+      type: "number",
+      title: "Confidence Score",
+      description: "Confidence score for the handedness classification"
+    }
+  },
+  required: ["label", "score"],
+  additionalProperties: false
+};
+var TypeHandGestureDetection = {
+  type: "object",
+  properties: {
+    gestures: {
+      type: "array",
+      items: TypeGesture,
+      title: "Gestures",
+      description: "Recognized gestures for this hand"
+    },
+    handedness: {
+      type: "array",
+      items: TypeHandedness,
+      title: "Handedness",
+      description: "Handedness classification (left/right)"
+    },
+    landmarks: {
+      type: "array",
+      items: TypeLandmark2,
+      title: "Landmarks",
+      description: "21 hand landmarks in image coordinates"
+    },
+    worldLandmarks: {
+      type: "array",
+      items: TypeLandmark2,
+      title: "World Landmarks",
+      description: "21 hand landmarks in 3D world coordinates (meters)"
+    }
+  },
+  required: ["gestures", "handedness", "landmarks", "worldLandmarks"],
+  additionalProperties: false
+};
+var GestureRecognizerInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema5,
+    numHands: {
+      type: "number",
+      minimum: 1,
+      maximum: 10,
+      default: 1,
+      title: "Number of Hands",
+      description: "The maximum number of hands to detect",
+      "x-ui-group": "Configuration"
+    },
+    minHandDetectionConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Hand Detection Confidence",
+      description: "Minimum confidence score for hand detection",
+      "x-ui-group": "Configuration"
+    },
+    minHandPresenceConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Hand Presence Confidence",
+      description: "Minimum confidence score for hand presence",
+      "x-ui-group": "Configuration"
+    },
+    minTrackingConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Tracking Confidence",
+      description: "Minimum confidence score for hand tracking",
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var GestureRecognizerOutputSchema = {
+  type: "object",
+  properties: {
+    hands: {
+      oneOf: [
+        { type: "array", items: TypeHandGestureDetection },
+        { type: "array", items: { type: "array", items: TypeHandGestureDetection } }
+      ],
+      title: "Hand Detections",
+      description: "Detected hands with gestures, handedness, and landmarks"
+    }
+  },
+  required: ["hands"],
+  additionalProperties: false
+};
+
+class GestureRecognizerTask extends AiVisionTask {
+  static type = "GestureRecognizerTask";
+  static category = "AI Vision Model";
+  static title = "Gesture Recognizer";
+  static description = "Recognizes hand gestures in images. Detects hand landmarks, identifies gestures (thumbs up, victory, etc.), and classifies handedness.";
+  static inputSchema() {
+    return GestureRecognizerInputSchema;
+  }
+  static outputSchema() {
+    return GestureRecognizerOutputSchema;
+  }
+}
+TaskRegistry6.registerTask(GestureRecognizerTask);
+var GestureRecognizer = (input, config) => {
+  return new GestureRecognizerTask(input, config).run();
+};
+Workflow6.prototype.GestureRecognizer = CreateWorkflow6(GestureRecognizerTask);
+// src/task/HandLandmarkerTask.ts
+import { CreateWorkflow as CreateWorkflow7, TaskRegistry as TaskRegistry7, Workflow as Workflow7 } from "@workglow/task-graph";
+var modelSchema6 = TypeReplicateArray(TypeModel("model:HandLandmarkerTask"));
+var TypeLandmark3 = {
+  type: "object",
+  properties: {
+    x: {
+      type: "number",
+      title: "X Coordinate",
+      description: "X coordinate normalized to [0.0, 1.0]"
+    },
+    y: {
+      type: "number",
+      title: "Y Coordinate",
+      description: "Y coordinate normalized to [0.0, 1.0]"
+    },
+    z: {
+      type: "number",
+      title: "Z Coordinate",
+      description: "Z coordinate (depth)"
+    }
+  },
+  required: ["x", "y", "z"],
+  additionalProperties: false
+};
+var TypeHandedness2 = {
+  type: "object",
+  properties: {
+    label: {
+      type: "string",
+      title: "Hand Label",
+      description: "Whether the hand is 'Left' or 'Right'"
+    },
+    score: {
+      type: "number",
+      title: "Confidence Score",
+      description: "Confidence score for the handedness classification"
+    }
+  },
+  required: ["label", "score"],
+  additionalProperties: false
+};
+var TypeHandDetection = {
+  type: "object",
+  properties: {
+    handedness: {
+      type: "array",
+      items: TypeHandedness2,
+      title: "Handedness",
+      description: "Handedness classification (left/right)"
+    },
+    landmarks: {
+      type: "array",
+      items: TypeLandmark3,
+      title: "Landmarks",
+      description: "21 hand landmarks in image coordinates"
+    },
+    worldLandmarks: {
+      type: "array",
+      items: TypeLandmark3,
+      title: "World Landmarks",
+      description: "21 hand landmarks in 3D world coordinates (meters)"
+    }
+  },
+  required: ["handedness", "landmarks", "worldLandmarks"],
+  additionalProperties: false
+};
+var HandLandmarkerInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema6,
+    numHands: {
+      type: "number",
+      minimum: 1,
+      maximum: 10,
+      default: 1,
+      title: "Number of Hands",
+      description: "The maximum number of hands to detect",
+      "x-ui-group": "Configuration"
+    },
+    minHandDetectionConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Hand Detection Confidence",
+      description: "Minimum confidence score for hand detection",
+      "x-ui-group": "Configuration"
+    },
+    minHandPresenceConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Hand Presence Confidence",
+      description: "Minimum confidence score for hand presence",
+      "x-ui-group": "Configuration"
+    },
+    minTrackingConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Tracking Confidence",
+      description: "Minimum confidence score for hand tracking",
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var HandLandmarkerOutputSchema = {
+  type: "object",
+  properties: {
+    hands: {
+      oneOf: [
+        { type: "array", items: TypeHandDetection },
+        { type: "array", items: { type: "array", items: TypeHandDetection } }
+      ],
+      title: "Hand Detections",
+      description: "Detected hands with handedness and landmarks"
+    }
+  },
+  required: ["hands"],
+  additionalProperties: false
+};
+
+class HandLandmarkerTask extends AiVisionTask {
+  static type = "HandLandmarkerTask";
+  static category = "AI Vision Model";
+  static title = "Hand Landmarker";
+  static description = "Detects hand landmarks in images. Identifies 21 hand landmarks and classifies left vs. right hands.";
+  static inputSchema() {
+    return HandLandmarkerInputSchema;
+  }
+  static outputSchema() {
+    return HandLandmarkerOutputSchema;
+  }
+}
+TaskRegistry7.registerTask(HandLandmarkerTask);
+var HandLandmarker = (input, config) => {
+  return new HandLandmarkerTask(input, config).run();
+};
+Workflow7.prototype.HandLandmarker = CreateWorkflow7(HandLandmarkerTask);
+// src/task/ImageClassificationTask.ts
+import { CreateWorkflow as CreateWorkflow8, TaskRegistry as TaskRegistry8, Workflow as Workflow8 } from "@workglow/task-graph";
+var modelSchema7 = TypeReplicateArray(TypeModel("model:ImageClassificationTask"));
+var ImageClassificationInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema7,
+    categories: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      title: "Categories",
+      description: "List of candidate categories (optional, if provided uses zero-shot classification)",
+      "x-ui-group": "Configuration"
+    },
+    maxCategories: {
+      type: "number",
+      minimum: 1,
+      maximum: 1000,
+      default: 5,
+      title: "Max Categories",
+      description: "The maximum number of categories to return",
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var ImageClassificationOutputSchema = {
+  type: "object",
+  properties: {
+    categories: {
+      oneOf: [
+        { type: "array", items: TypeCategory },
+        { type: "array", items: { type: "array", items: TypeCategory } }
+      ],
+      title: "Categories",
+      description: "The classification categories with their scores"
+    }
+  },
+  required: ["categories"],
+  additionalProperties: false
+};
+
+class ImageClassificationTask extends AiVisionTask {
+  static type = "ImageClassificationTask";
+  static category = "AI Vision Model";
+  static title = "Image Classification";
+  static description = "Classifies images into categories using vision models. Supports zero-shot classification when categories are provided.";
+  static inputSchema() {
+    return ImageClassificationInputSchema;
+  }
+  static outputSchema() {
+    return ImageClassificationOutputSchema;
+  }
+}
+TaskRegistry8.registerTask(ImageClassificationTask);
+var ImageClassification = (input, config) => {
+  return new ImageClassificationTask(input, config).run();
+};
+Workflow8.prototype.ImageClassification = CreateWorkflow8(ImageClassificationTask);
+// src/task/ImageEmbeddingTask.ts
+import { CreateWorkflow as CreateWorkflow9, TaskRegistry as TaskRegistry9, Workflow as Workflow9 } from "@workglow/task-graph";
+var modelSchema8 = TypeReplicateArray(TypeModel("model:ImageEmbeddingTask"));
+var embeddingSchema = TypedArraySchema({
+  title: "Embedding",
+  description: "The image embedding vector"
+});
+var ImageEmbeddingInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema8
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var ImageEmbeddingOutputSchema = {
+  type: "object",
+  properties: {
+    vector: {
+      oneOf: [embeddingSchema, { type: "array", items: embeddingSchema }],
+      title: "Embedding",
+      description: "The image embedding vector"
+    }
+  },
+  required: ["vector"],
+  additionalProperties: false
+};
+
+class ImageEmbeddingTask extends AiVisionTask {
+  static type = "ImageEmbeddingTask";
+  static category = "AI Vision Model";
+  static title = "Image Embedding";
+  static description = "Generates embeddings from images using vision models";
+  static inputSchema() {
+    return ImageEmbeddingInputSchema;
+  }
+  static outputSchema() {
+    return ImageEmbeddingOutputSchema;
+  }
+}
+TaskRegistry9.registerTask(ImageEmbeddingTask);
+var ImageEmbedding = (input, config) => {
+  return new ImageEmbeddingTask(input, config).run();
+};
+Workflow9.prototype.ImageEmbedding = CreateWorkflow9(ImageEmbeddingTask);
+// src/task/ImageSegmentationTask.ts
+import { CreateWorkflow as CreateWorkflow10, TaskRegistry as TaskRegistry10, Workflow as Workflow10 } from "@workglow/task-graph";
+var modelSchema9 = TypeReplicateArray(TypeModel("model:ImageSegmentationTask"));
+var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
-    parser: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema9,
+    threshold: {
+      type: "number",
+      title: "Threshold",
+      description: "The threshold for filtering masks by score",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      "x-ui-group": "Configuration"
+    },
+    maskThreshold: {
+      type: "number",
+      title: "Mask Threshold",
+      description: "Threshold to use when turning predicted masks into binary values",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var segmentationMaskSchema = {
+  type: "object",
+  properties: {
+    label: {
       type: "string",
-      enum: ["txt", "md"],
-      title: "Document Kind",
-      description: "The kind of document (txt or md)"
+      title: "Label",
+      description: "The label of the segmented region"
+    },
+    score: {
+      type: "number",
+      title: "Score",
+      description: "The confidence score for this segmentation",
+      minimum: 0,
+      maximum: 1
+    },
+    mask: {
+      type: "object",
+      format: "image",
+      title: "Mask",
+      description: "Mask image"
     }
   },
-  required: ["parser"],
+  required: ["label", "score", "mask"],
   additionalProperties: false
 };
-var outputSchema = {
+var ImageSegmentationOutputSchema = {
   type: "object",
   properties: {
-    texts: {
-      type: "array",
-      items: { type: "string" },
-      title: "Text Chunks",
-      description: "The text chunks of the document"
+    masks: {
+      oneOf: [
+        { type: "array", items: segmentationMaskSchema },
+        { type: "array", items: { type: "array", items: segmentationMaskSchema } }
+      ],
+      title: "Segmentation Masks",
+      description: "The segmented regions with their labels, scores, and masks"
     }
   },
-  required: ["texts"],
+  required: ["masks"],
   additionalProperties: false
 };
 
-class DocumentSplitterTask extends Task {
-  static type = "DocumentSplitterTask";
-  static category = "Document";
-  static title = "Document Splitter";
-  static description = "Splits documents into text chunks for processing";
+class ImageSegmentationTask extends AiVisionTask {
+  static type = "ImageSegmentationTask";
+  static category = "AI Vision Model";
+  static title = "Image Segmentation";
+  static description = "Segments images into regions with labels using computer vision models";
   static inputSchema() {
-    return inputSchema;
+    return ImageSegmentationInputSchema;
   }
   static outputSchema() {
-    return outputSchema;
+    return ImageSegmentationOutputSchema;
   }
-  flattenFragmentsToTexts(item) {
-    if (item instanceof Document) {
-      const texts = [];
-      item.fragments.forEach((fragment) => {
-        texts.push(...this.flattenFragmentsToTexts(fragment));
-      });
-      return texts;
-    } else {
-      return [item.content];
+}
+TaskRegistry10.registerTask(ImageSegmentationTask);
+var ImageSegmentation = (input, config) => {
+  return new ImageSegmentationTask(input, config).run();
+};
+Workflow10.prototype.ImageSegmentation = CreateWorkflow10(ImageSegmentationTask);
+// src/task/ImageToTextTask.ts
+import { CreateWorkflow as CreateWorkflow11, TaskRegistry as TaskRegistry11, Workflow as Workflow11 } from "@workglow/task-graph";
+var modelSchema10 = TypeReplicateArray(TypeModel("model:ImageToTextTask"));
+var generatedTextSchema = {
+  type: "string",
+  title: "Text",
+  description: "The generated text description"
+};
+var ImageToTextInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema10,
+    maxTokens: {
+      type: "number",
+      title: "Max Tokens",
+      description: "The maximum number of tokens to generate",
+      minimum: 1,
+      maximum: 4096,
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var ImageToTextOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      oneOf: [generatedTextSchema, { type: "array", items: generatedTextSchema }],
+      title: generatedTextSchema.title,
+      description: generatedTextSchema.description
     }
+  },
+  required: ["text"],
+  additionalProperties: false
+};
+
+class ImageToTextTask extends AiVisionTask {
+  static type = "ImageToTextTask";
+  static category = "AI Vision Model";
+  static title = "Image to Text";
+  static description = "Generates text descriptions from images using vision-language models";
+  static inputSchema() {
+    return ImageToTextInputSchema;
   }
-  async executeReactive() {
-    return { texts: this.flattenFragmentsToTexts(this.runInputData.file) };
+  static outputSchema() {
+    return ImageToTextOutputSchema;
   }
 }
-TaskRegistry.registerTask(DocumentSplitterTask);
-var DocumentSplitter = (input) => {
-  return new DocumentSplitterTask(input).run();
+TaskRegistry11.registerTask(ImageToTextTask);
+var ImageToText = (input, config) => {
+  return new ImageToTextTask(input, config).run();
 };
-Workflow.prototype.DocumentSplitter = CreateWorkflow(DocumentSplitterTask);
-// src/task/DownloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow2, TaskRegistry as TaskRegistry2, Workflow as Workflow2 } from "@workglow/task-graph";
-var modelSchema = TypeReplicateArray(TypeModel("model"));
-var DownloadModelInputSchema = {
+Workflow11.prototype.ImageToText = CreateWorkflow11(ImageToTextTask);
+// src/task/ObjectDetectionTask.ts
+import { CreateWorkflow as CreateWorkflow12, TaskRegistry as TaskRegistry12, Workflow as Workflow12 } from "@workglow/task-graph";
+var modelSchema11 = TypeReplicateArray(TypeModel("model:ObjectDetectionTask"));
+var detectionSchema = {
   type: "object",
   properties: {
-    model: modelSchema
+    label: {
+      type: "string",
+      title: "Label",
+      description: "The label of the detected object"
+    },
+    score: {
+      type: "number",
+      title: "Confidence Score",
+      description: "The confidence score for this detection",
+      minimum: 0,
+      maximum: 1
+    },
+    box: TypeBoundingBox
   },
-  required: ["model"],
+  required: ["label", "score", "box"],
   additionalProperties: false
 };
-var DownloadModelOutputSchema = {
+var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema11,
+    labels: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      title: "Labels",
+      description: "List of object labels to detect (optional, if provided uses zero-shot detection)",
+      "x-ui-group": "Configuration"
+    },
+    threshold: {
+      type: "number",
+      title: "Threshold",
+      description: "The threshold for filtering detections by score",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      "x-ui-group": "Configuration"
+    }
   },
-  required: ["model"],
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var ObjectDetectionOutputSchema = {
+  type: "object",
+  properties: {
+    detections: {
+      oneOf: [
+        { type: "array", items: detectionSchema },
+        { type: "array", items: { type: "array", items: detectionSchema } }
+      ],
+      title: "Detections",
+      description: "The detected objects with their labels, scores, and bounding boxes"
+    }
+  },
+  required: ["detections"],
   additionalProperties: false
 };
 
-class DownloadModelTask extends AiTask {
-  static type = "DownloadModelTask";
-  static category = "AI Text Model";
-  static title = "Download Model";
-  static description = "Downloads and caches AI models locally with progress tracking";
+class ObjectDetectionTask extends AiVisionTask {
+  static type = "ObjectDetectionTask";
+  static category = "AI Vision Model";
+  static title = "Object Detection";
+  static description = "Detects objects in images using vision models. Supports zero-shot detection when labels are provided.";
   static inputSchema() {
-    return DownloadModelInputSchema;
+    return ObjectDetectionInputSchema;
   }
   static outputSchema() {
-    return DownloadModelOutputSchema;
-  }
-  static cacheable = false;
-  files = [];
-  constructor(input, config = {}) {
-    super(input, config);
-    this.on("progress", this.processProgress.bind(this));
-    this.on("start", () => {
-      this.files = [];
-    });
+    return ObjectDetectionOutputSchema;
   }
-  processProgress(progress, message = "", details) {
-    if (details?.file) {
-      const file = this.files.find((f) => f.file === details.file);
-      if (file) {
-        file.progress = details.progress;
-      } else {
-        this.files.push({ file: details.file, progress: details.progress });
-      }
-      this.progress = this.files.reduce((acc, f) => acc + f.progress, 0) / this.files.length;
-    } else {
-      this.progress = progress;
+}
+TaskRegistry12.registerTask(ObjectDetectionTask);
+var ObjectDetection = (input, config) => {
+  return new ObjectDetectionTask(input, config).run();
+};
+Workflow12.prototype.ObjectDetection = CreateWorkflow12(ObjectDetectionTask);
+// src/task/PoseLandmarkerTask.ts
+import { CreateWorkflow as CreateWorkflow13, TaskRegistry as TaskRegistry13, Workflow as Workflow13 } from "@workglow/task-graph";
+var modelSchema12 = TypeReplicateArray(TypeModel("model:PoseLandmarkerTask"));
+var TypePoseLandmark = {
+  type: "object",
+  properties: {
+    x: {
+      type: "number",
+      title: "X Coordinate",
+      description: "X coordinate normalized to [0.0, 1.0]"
+    },
+    y: {
+      type: "number",
+      title: "Y Coordinate",
+      description: "Y coordinate normalized to [0.0, 1.0]"
+    },
+    z: {
+      type: "number",
+      title: "Z Coordinate",
+      description: "Z coordinate (depth)"
+    },
+    visibility: {
+      type: "number",
+      title: "Visibility",
+      description: "Likelihood of the landmark being visible within the image"
+    },
+    presence: {
+      type: "number",
+      title: "Presence",
+      description: "Likelihood of the landmark being present in the image"
+    }
+  },
+  required: ["x", "y", "z"],
+  additionalProperties: false
+};
+var TypeSegmentationMask = {
+  type: "object",
+  properties: {
+    data: {
+      type: "object",
+      title: "Mask Data",
+      description: "Canvas or image data containing the segmentation mask"
+    },
+    width: {
+      type: "number",
+      title: "Width",
+      description: "Width of the segmentation mask"
+    },
+    height: {
+      type: "number",
+      title: "Height",
+      description: "Height of the segmentation mask"
+    }
+  },
+  required: ["data", "width", "height"],
+  additionalProperties: false
+};
+var TypePoseDetection = {
+  type: "object",
+  properties: {
+    landmarks: {
+      type: "array",
+      items: TypePoseLandmark,
+      title: "Landmarks",
+      description: "33 pose landmarks in image coordinates"
+    },
+    worldLandmarks: {
+      type: "array",
+      items: TypePoseLandmark,
+      title: "World Landmarks",
+      description: "33 pose landmarks in 3D world coordinates (meters)"
+    },
+    segmentationMask: TypeSegmentationMask
+  },
+  required: ["landmarks", "worldLandmarks"],
+  additionalProperties: false
+};
+var PoseLandmarkerInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema12,
+    numPoses: {
+      type: "number",
+      minimum: 1,
+      maximum: 10,
+      default: 1,
+      title: "Number of Poses",
+      description: "The maximum number of poses to detect",
+      "x-ui-group": "Configuration"
+    },
+    minPoseDetectionConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Pose Detection Confidence",
+      description: "Minimum confidence score for pose detection",
+      "x-ui-group": "Configuration"
+    },
+    minPosePresenceConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Pose Presence Confidence",
+      description: "Minimum confidence score for pose presence",
+      "x-ui-group": "Configuration"
+    },
+    minTrackingConfidence: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      default: 0.5,
+      title: "Min Tracking Confidence",
+      description: "Minimum confidence score for pose tracking",
+      "x-ui-group": "Configuration"
+    },
+    outputSegmentationMasks: {
+      type: "boolean",
+      default: false,
+      title: "Output Segmentation Masks",
+      description: "Whether to output segmentation masks for detected poses",
+      "x-ui-group": "Configuration"
     }
+  },
+  required: ["image", "model"],
+  additionalProperties: false
+};
+var PoseLandmarkerOutputSchema = {
+  type: "object",
+  properties: {
+    poses: {
+      oneOf: [
+        { type: "array", items: TypePoseDetection },
+        { type: "array", items: { type: "array", items: TypePoseDetection } }
+      ],
+      title: "Pose Detections",
+      description: "Detected poses with landmarks and optional segmentation masks"
+    }
+  },
+  required: ["poses"],
+  additionalProperties: false
+};
+
+class PoseLandmarkerTask extends AiVisionTask {
+  static type = "PoseLandmarkerTask";
+  static category = "AI Vision Model";
+  static title = "Pose Landmarker";
+  static description = "Detects pose landmarks in images. Identifies 33 body landmarks for pose estimation and optional segmentation.";
+  static inputSchema() {
+    return PoseLandmarkerInputSchema;
+  }
+  static outputSchema() {
+    return PoseLandmarkerOutputSchema;
   }
 }
-TaskRegistry2.registerTask(DownloadModelTask);
-var DownloadModel = (input, config) => {
-  return new DownloadModelTask(input, config).run();
+TaskRegistry13.registerTask(PoseLandmarkerTask);
+var PoseLandmarker = (input, config) => {
+  return new PoseLandmarkerTask(input, config).run();
 };
-Workflow2.prototype.DownloadModel = CreateWorkflow2(DownloadModelTask);
-// src/task/TextClassifierTask.ts
-import { CreateWorkflow as CreateWorkflow3, TaskRegistry as TaskRegistry3, Workflow as Workflow3 } from "@workglow/task-graph";
-var modelSchema2 = TypeReplicateArray(TypeModel("model:TextClassifierTask"));
-var TextClassifierInputSchema = {
+Workflow13.prototype.PoseLandmarker = CreateWorkflow13(PoseLandmarkerTask);
+// src/task/TextClassificationTask.ts
+import { CreateWorkflow as CreateWorkflow14, TaskRegistry as TaskRegistry14, Workflow as Workflow14 } from "@workglow/task-graph";
+var modelSchema13 = TypeReplicateArray(TypeModel("model:TextClassificationTask"));
+var TextClassificationInputSchema = {
   type: "object",
   properties: {
     text: TypeReplicateArray({
@@ -827,20 +2118,30 @@ var TextClassifierInputSchema = {
       title: "Text",
       description: "The text to classify"
     }),
+    candidateLabels: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      title: "Candidate Labels",
+      description: "List of candidate labels (optional, if provided uses zero-shot classification)",
+      "x-ui-group": "Configuration"
+    },
     maxCategories: {
       type: "number",
       minimum: 1,
       maximum: 1000,
       default: 5,
       title: "Max Categories",
-      description: "The maximum number of categories to return"
+      description: "The maximum number of categories to return",
+      "x-ui-group": "Configuration"
     },
-    model: modelSchema2
+    model: modelSchema13
   },
   required: ["text", "model"],
   additionalProperties: false
 };
-var TextClassifierOutputSchema = {
+var TextClassificationOutputSchema = {
   type: "object",
   properties: {
     categories: {
@@ -870,26 +2171,26 @@ var TextClassifierOutputSchema = {
   additionalProperties: false
 };
 
-class TextClassifierTask extends AiTask {
-  static type = "TextClassifierTask";
+class TextClassificationTask extends AiTask {
+  static type = "TextClassificationTask";
   static category = "AI Text Model";
   static title = "Text Classifier";
-  static description = "Classifies text into predefined categories using language models";
+  static description = "Classifies text into categories using language models. Supports zero-shot classification when candidate labels are provided.";
   static inputSchema() {
-    return TextClassifierInputSchema;
+    return TextClassificationInputSchema;
   }
   static outputSchema() {
-    return TextClassifierOutputSchema;
+    return TextClassificationOutputSchema;
   }
 }
-TaskRegistry3.registerTask(TextClassifierTask);
-var TextClassifier = (input, config) => {
-  return new TextClassifierTask(input, config).run();
+TaskRegistry14.registerTask(TextClassificationTask);
+var TextClassification = (input, config) => {
+  return new TextClassificationTask(input, config).run();
 };
-Workflow3.prototype.TextClassifier = CreateWorkflow3(TextClassifierTask);
+Workflow14.prototype.TextClassification = CreateWorkflow14(TextClassificationTask);
 // src/task/TextEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow4, TaskRegistry as TaskRegistry4, Workflow as Workflow4 } from "@workglow/task-graph";
-var modelSchema3 = TypeReplicateArray(TypeModel("model:TextEmbeddingTask"));
+import { CreateWorkflow as CreateWorkflow15, TaskRegistry as TaskRegistry15, Workflow as Workflow15 } from "@workglow/task-graph";
+var modelSchema14 = TypeReplicateArray(TypeModel("model:TextEmbeddingTask"));
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -898,7 +2199,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema3
+    model: modelSchema14
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -927,14 +2228,14 @@ class TextEmbeddingTask extends AiTask {
     return TextEmbeddingOutputSchema;
   }
 }
-TaskRegistry4.registerTask(TextEmbeddingTask);
+TaskRegistry15.registerTask(TextEmbeddingTask);
 var TextEmbedding = async (input, config) => {
   return new TextEmbeddingTask(input, config).run();
 };
-Workflow4.prototype.TextEmbedding = CreateWorkflow4(TextEmbeddingTask);
+Workflow15.prototype.TextEmbedding = CreateWorkflow15(TextEmbeddingTask);
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow5, TaskRegistry as TaskRegistry5, Workflow as Workflow5 } from "@workglow/task-graph";
-var modelSchema4 = TypeReplicateArray(TypeModel("model:TextFillMaskTask"));
+import { CreateWorkflow as CreateWorkflow16, TaskRegistry as TaskRegistry16, Workflow as Workflow16 } from "@workglow/task-graph";
+var modelSchema15 = TypeReplicateArray(TypeModel("model:TextFillMaskTask"));
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -943,7 +2244,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     }),
-    model: modelSchema4
+    model: modelSchema15
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -986,8 +2287,8 @@ var TextFillMaskOutputSchema = {
 class TextFillMaskTask extends AiTask {
   static type = "TextFillMaskTask";
   static category = "AI Text Model";
-  static title = "Text Fill Mask";
-  static description = "Fills masked tokens in text using language models";
+  static title = "Fill Mask";
+  static description = "Fills masked tokens in text";
   static inputSchema() {
     return TextFillMaskInputSchema;
   }
@@ -995,23 +2296,23 @@ class TextFillMaskTask extends AiTask {
     return TextFillMaskOutputSchema;
   }
 }
-TaskRegistry5.registerTask(TextFillMaskTask);
+TaskRegistry16.registerTask(TextFillMaskTask);
 var TextFillMask = (input, config) => {
   return new TextFillMaskTask(input, config).run();
 };
-Workflow5.prototype.TextFillMask = CreateWorkflow5(TextFillMaskTask);
+Workflow16.prototype.TextFillMask = CreateWorkflow16(TextFillMaskTask);
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow6, TaskRegistry as TaskRegistry6, Workflow as Workflow6 } from "@workglow/task-graph";
-var generatedTextSchema = {
+import { CreateWorkflow as CreateWorkflow17, TaskRegistry as TaskRegistry17, Workflow as Workflow17 } from "@workglow/task-graph";
+var generatedTextSchema2 = {
   type: "string",
   title: "Text",
   description: "The generated text"
 };
-var modelSchema5 = TypeReplicateArray(TypeModel("model:TextGenerationTask"));
+var modelSchema16 = TypeReplicateArray(TypeModel("model:TextGenerationTask"));
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema5,
+    model: modelSchema16,
     prompt: TypeReplicateArray({
       type: "string",
       title: "Prompt",
@@ -1065,9 +2366,9 @@ var TextGenerationOutputSchema = {
   type: "object",
   properties: {
     text: {
-      oneOf: [generatedTextSchema, { type: "array", items: generatedTextSchema }],
-      title: generatedTextSchema.title,
-      description: generatedTextSchema.description
+      oneOf: [generatedTextSchema2, { type: "array", items: generatedTextSchema2 }],
+      title: generatedTextSchema2.title,
+      description: generatedTextSchema2.description
     }
   },
   required: ["text"],
@@ -1086,14 +2387,14 @@ class TextGenerationTask extends AiTask {
     return TextGenerationOutputSchema;
   }
 }
-TaskRegistry6.registerTask(TextGenerationTask);
+TaskRegistry17.registerTask(TextGenerationTask);
 var TextGeneration = (input, config) => {
   return new TextGenerationTask(input, config).run();
 };
-Workflow6.prototype.TextGeneration = CreateWorkflow6(TextGenerationTask);
+Workflow17.prototype.TextGeneration = CreateWorkflow17(TextGenerationTask);
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow7, TaskRegistry as TaskRegistry7, Workflow as Workflow7 } from "@workglow/task-graph";
-var modelSchema6 = TypeReplicateArray(TypeModel("model:TextLanguageDetectionTask"));
+import { CreateWorkflow as CreateWorkflow18, TaskRegistry as TaskRegistry18, Workflow as Workflow18 } from "@workglow/task-graph";
+var modelSchema17 = TypeReplicateArray(TypeModel("model:TextLanguageDetectionTask"));
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -1110,7 +2411,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema6
+    model: modelSchema17
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1157,14 +2458,14 @@ class TextLanguageDetectionTask extends AiTask {
     return TextLanguageDetectionOutputSchema;
   }
 }
-TaskRegistry7.registerTask(TextLanguageDetectionTask);
+TaskRegistry18.registerTask(TextLanguageDetectionTask);
 var TextLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(input, config).run();
 };
-Workflow7.prototype.TextLanguageDetection = CreateWorkflow7(TextLanguageDetectionTask);
+Workflow18.prototype.TextLanguageDetection = CreateWorkflow18(TextLanguageDetectionTask);
 // src/task/TextNamedEntityRecognitionTask.ts
-import { CreateWorkflow as CreateWorkflow8, TaskRegistry as TaskRegistry8, Workflow as Workflow8 } from "@workglow/task-graph";
-var modelSchema7 = TypeReplicateArray(TypeModel("model:NamedEntityRecognitionTask"));
+import { CreateWorkflow as CreateWorkflow19, TaskRegistry as TaskRegistry19, Workflow as Workflow19 } from "@workglow/task-graph";
+var modelSchema18 = TypeReplicateArray(TypeModel("model:NamedEntityRecognitionTask"));
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
@@ -1183,7 +2484,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema7
+    model: modelSchema18
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1226,8 +2527,8 @@ var TextNamedEntityRecognitionOutputSchema = {
 class TextNamedEntityRecognitionTask extends AiTask {
   static type = "TextNamedEntityRecognitionTask";
   static category = "AI Text Model";
-  static title = "Text Named Entity Recognition";
-  static description = "Extracts named entities from text using language models";
+  static title = "Named Entity Recognition";
+  static description = "Extracts named entities from text";
   static inputSchema() {
     return TextNamedEntityRecognitionInputSchema;
   }
@@ -1235,13 +2536,13 @@ class TextNamedEntityRecognitionTask extends AiTask {
     return TextNamedEntityRecognitionOutputSchema;
   }
 }
-TaskRegistry8.registerTask(TextNamedEntityRecognitionTask);
+TaskRegistry19.registerTask(TextNamedEntityRecognitionTask);
 var TextNamedEntityRecognition = (input, config) => {
   return new TextNamedEntityRecognitionTask(input, config).run();
 };
-Workflow8.prototype.TextNamedEntityRecognition = CreateWorkflow8(TextNamedEntityRecognitionTask);
+Workflow19.prototype.TextNamedEntityRecognition = CreateWorkflow19(TextNamedEntityRecognitionTask);
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow9, TaskRegistry as TaskRegistry9, Workflow as Workflow9 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow20, TaskRegistry as TaskRegistry20, Workflow as Workflow20 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -1257,13 +2558,13 @@ var textSchema = {
   title: "Text",
   description: "The generated text"
 };
-var modelSchema8 = TypeReplicateArray(TypeModel("model:TextQuestionAnswerTask"));
+var modelSchema19 = TypeReplicateArray(TypeModel("model:TextQuestionAnswerTask"));
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: TypeReplicateArray(contextSchema),
     question: TypeReplicateArray(questionSchema),
-    model: modelSchema8
+    model: modelSchema19
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -1293,14 +2594,14 @@ class TextQuestionAnswerTask extends AiTask {
     return TextQuestionAnswerOutputSchema;
   }
 }
-TaskRegistry9.registerTask(TextQuestionAnswerTask);
+TaskRegistry20.registerTask(TextQuestionAnswerTask);
 var TextQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(input, config).run();
 };
-Workflow9.prototype.TextQuestionAnswer = CreateWorkflow9(TextQuestionAnswerTask);
+Workflow20.prototype.TextQuestionAnswer = CreateWorkflow20(TextQuestionAnswerTask);
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow10, TaskRegistry as TaskRegistry10, Workflow as Workflow10 } from "@workglow/task-graph";
-var modelSchema9 = TypeReplicateArray(TypeModel("model:TextRewriterTask"));
+import { CreateWorkflow as CreateWorkflow21, TaskRegistry as TaskRegistry21, Workflow as Workflow21 } from "@workglow/task-graph";
+var modelSchema20 = TypeReplicateArray(TypeModel("model:TextRewriterTask"));
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -1314,7 +2615,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     }),
-    model: modelSchema9
+    model: modelSchema20
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -1344,14 +2645,14 @@ class TextRewriterTask extends AiTask {
     return TextRewriterOutputSchema;
   }
 }
-TaskRegistry10.registerTask(TextRewriterTask);
+TaskRegistry21.registerTask(TextRewriterTask);
 var TextRewriter = (input, config) => {
   return new TextRewriterTask(input, config).run();
 };
-Workflow10.prototype.TextRewriter = CreateWorkflow10(TextRewriterTask);
+Workflow21.prototype.TextRewriter = CreateWorkflow21(TextRewriterTask);
 // src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow11, TaskRegistry as TaskRegistry11, Workflow as Workflow11 } from "@workglow/task-graph";
-var modelSchema10 = TypeReplicateArray(TypeModel("model:TextSummaryTask"));
+import { CreateWorkflow as CreateWorkflow22, TaskRegistry as TaskRegistry22, Workflow as Workflow22 } from "@workglow/task-graph";
+var modelSchema21 = TypeReplicateArray(TypeModel("model:TextSummaryTask"));
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
@@ -1360,7 +2661,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     }),
-    model: modelSchema10
+    model: modelSchema21
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1390,14 +2691,14 @@ class TextSummaryTask extends AiTask {
     return TextSummaryOutputSchema;
   }
 }
-TaskRegistry11.registerTask(TextSummaryTask);
+TaskRegistry22.registerTask(TextSummaryTask);
 var TextSummary = async (input, config) => {
   return new TextSummaryTask(input, config).run();
 };
-Workflow11.prototype.TextSummary = CreateWorkflow11(TextSummaryTask);
+Workflow22.prototype.TextSummary = CreateWorkflow22(TextSummaryTask);
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow12, TaskRegistry as TaskRegistry12, Workflow as Workflow12 } from "@workglow/task-graph";
-var modelSchema11 = TypeReplicateArray(TypeModel("model:TextTranslationTask"));
+import { CreateWorkflow as CreateWorkflow23, TaskRegistry as TaskRegistry23, Workflow as Workflow23 } from "@workglow/task-graph";
+var modelSchema22 = TypeReplicateArray(TypeModel("model:TextTranslationTask"));
 var translationTextSchema = {
   type: "string",
   title: "Text",
@@ -1423,7 +2724,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     })),
-    model: modelSchema11
+    model: modelSchema22
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -1459,18 +2760,18 @@ class TextTranslationTask extends AiTask {
     return TextTranslationOutputSchema;
   }
 }
-TaskRegistry12.registerTask(TextTranslationTask);
+TaskRegistry23.registerTask(TextTranslationTask);
 var TextTranslation = (input, config) => {
   return new TextTranslationTask(input, config).run();
 };
-Workflow12.prototype.TextTranslation = CreateWorkflow12(TextTranslationTask);
+Workflow23.prototype.TextTranslation = CreateWorkflow23(TextTranslationTask);
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow13, TaskRegistry as TaskRegistry13, Workflow as Workflow13 } from "@workglow/task-graph";
-var modelSchema12 = TypeReplicateArray(TypeModel("model"));
+import { CreateWorkflow as CreateWorkflow24, TaskRegistry as TaskRegistry24, Workflow as Workflow24 } from "@workglow/task-graph";
+var modelSchema23 = TypeReplicateArray(TypeModel("model"));
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema12
+    model: modelSchema23
   },
   required: ["model"],
   additionalProperties: false
@@ -1478,7 +2779,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema12
+    model: modelSchema23
   },
   required: ["model"],
   additionalProperties: false
@@ -1497,18 +2798,18 @@ class UnloadModelTask extends AiTask {
   }
   static cacheable = false;
 }
-TaskRegistry13.registerTask(UnloadModelTask);
+TaskRegistry24.registerTask(UnloadModelTask);
 var UnloadModel = (input, config) => {
   return new UnloadModelTask(input, config).run();
 };
-Workflow13.prototype.UnloadModel = CreateWorkflow13(UnloadModelTask);
+Workflow24.prototype.UnloadModel = CreateWorkflow24(UnloadModelTask);
 // src/task/VectorSimilarityTask.ts
 import {
   ArrayTask,
-  CreateWorkflow as CreateWorkflow14,
+  CreateWorkflow as CreateWorkflow25,
   TaskError,
-  TaskRegistry as TaskRegistry14,
-  Workflow as Workflow14
+  TaskRegistry as TaskRegistry25,
+  Workflow as Workflow25
 } from "@workglow/task-graph";
 var SimilarityFn = {
   COSINE: "cosine",
@@ -1602,11 +2903,11 @@ class VectorSimilarityTask extends ArrayTask {
     };
   }
 }
-TaskRegistry14.registerTask(VectorSimilarityTask);
+TaskRegistry25.registerTask(VectorSimilarityTask);
 var Similarity = (input, config) => {
   return new VectorSimilarityTask(input, config).run();
 };
-Workflow14.prototype.Similarity = CreateWorkflow14(VectorSimilarityTask);
+Workflow25.prototype.Similarity = CreateWorkflow25(VectorSimilarityTask);
 function inner(arr1, arr2) {
   return 1 - arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
 }
@@ -1650,6 +2951,10 @@ export {
   TypeModelAsString,
   TypeModel,
   TypeLanguage,
+  TypeImageInput,
+  TypeCategory,
+  TypeBoundingBox,
+  TypeAudioInput,
   TextTranslationTask,
   TextTranslationOutputSchema,
   TextTranslationInputSchema,
@@ -1687,19 +2992,59 @@ export {
   TextEmbeddingOutputSchema,
   TextEmbeddingInputSchema,
   TextEmbedding,
-  TextClassifierTask,
-  TextClassifierOutputSchema,
-  TextClassifierInputSchema,
-  TextClassifier,
+  TextClassificationTask,
+  TextClassificationOutputSchema,
+  TextClassificationInputSchema,
+  TextClassification,
   TableFragment,
   SimilarityFn,
   Similarity,
+  PoseLandmarkerTask,
+  PoseLandmarkerOutputSchema,
+  PoseLandmarkerInputSchema,
+  PoseLandmarker,
+  ObjectDetectionTask,
+  ObjectDetectionOutputSchema,
+  ObjectDetectionInputSchema,
+  ObjectDetection,
   ModelSchema,
   ModelRepository,
   ModelPrimaryKeyNames,
   MODEL_REPOSITORY,
   InMemoryModelRepository,
+  ImageToTextTask,
+  ImageToTextOutputSchema,
+  ImageToTextInputSchema,
+  ImageToText,
+  ImageSegmentationTask,
+  ImageSegmentationOutputSchema,
+  ImageSegmentationInputSchema,
+  ImageSegmentation,
   ImageFragment,
+  ImageEmbeddingTask,
+  ImageEmbeddingOutputSchema,
+  ImageEmbeddingInputSchema,
+  ImageEmbedding,
+  ImageClassificationTask,
+  ImageClassificationOutputSchema,
+  ImageClassificationInputSchema,
+  ImageClassification,
+  HandLandmarkerTask,
+  HandLandmarkerOutputSchema,
+  HandLandmarkerInputSchema,
+  HandLandmarker,
+  GestureRecognizerTask,
+  GestureRecognizerOutputSchema,
+  GestureRecognizerInputSchema,
+  GestureRecognizer,
+  FaceLandmarkerTask,
+  FaceLandmarkerOutputSchema,
+  FaceLandmarkerInputSchema,
+  FaceLandmarker,
+  FaceDetectorTask,
+  FaceDetectorOutputSchema,
+  FaceDetectorInputSchema,
+  FaceDetector,
   DownloadModelTask,
   DownloadModel,
   DocumentSplitterTask,
@@ -1709,9 +3054,13 @@ export {
   DocumentConverterMarkdown,
   DocumentBaseFragment,
   Document,
+  BackgroundRemovalTask,
+  BackgroundRemovalOutputSchema,
+  BackgroundRemovalInputSchema,
+  BackgroundRemoval,
   AiTask,
   AiProviderRegistry,
   AiJob
 };
 
-//# debugId=4EF87B775AAC634764756E2164756E21
+//# debugId=64CEDA66BE50C92264756E2164756E21