@workglow/ai 0.0.71 → 0.0.72

package/dist/browser.js

@@ -446,6 +446,249 @@ class DocumentConverterText extends DocumentConverter {
     return new Document(this.text, this.metadata);
   }
 }
+// src/task/BackgroundRemovalTask.ts
+import { CreateWorkflow, TaskRegistry, Workflow } from "@workglow/task-graph";
+
+// src/task/base/AiTaskSchemas.ts
+import {
+  FromSchemaDefaultOptions
+} from "@workglow/util";
+var TypedArrayType = null;
+var TypedArraySchemaOptions = {
+  ...FromSchemaDefaultOptions,
+  deserialize: [
+    {
+      pattern: { format: "TypedArray" },
+      output: TypedArrayType
+    }
+  ]
+};
+var TypedArraySchema = (annotations = {}) => ({
+  oneOf: [
+    {
+      type: "array",
+      items: { type: "number", format: "Float64" },
+      title: "Float64Array",
+      description: "A 64-bit floating point array",
+      format: "Float64Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Float32" },
+      title: "Float32Array",
+      description: "A 32-bit floating point array",
+      format: "Float32Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Int32" },
+      title: "Int32Array",
+      description: "A 32-bit integer array",
+      format: "Int32Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Int16" },
+      title: "Int16Array",
+      description: "A 16-bit integer array",
+      format: "Int16Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Int8" },
+      title: "Int8Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Uint8" },
+      title: "Uint8Array",
+      description: "A 8-bit unsigned integer array",
+      format: "Uint8Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Uint16" },
+      title: "Uint16Array",
+      description: "A 16-bit unsigned integer array",
+      format: "Uint16Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Uint32" },
+      title: "Uint32Array",
+      description: "A 32-bit unsigned integer array",
+      format: "Uint32Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Uint8Clamped" },
+      title: "Uint8ClampedArray",
+      description: "A 8-bit unsigned integer array with values clamped to 0-255",
+      format: "Uint8ClampedArray"
+    }
+  ],
+  format: "TypedArray",
+  ...annotations
+});
+var TypeLanguage = (annotations = {}) => ({
+  type: "string",
+  title: "Language",
+  description: "The language to use",
+  maxLength: 2,
+  minLength: 2,
+  ...annotations
+});
+function TypeModelAsString(semantic = "model", options = {}) {
+  if (semantic !== "model" && !semantic.startsWith("model:")) {
+    throw new Error("Invalid semantic value");
+  }
+  const taskName = semantic.startsWith("model:") ? semantic.slice(6).replace(/Task$/, "").replaceAll(/[A-Z]/g, (char) => " " + char.toLowerCase()).trim() : null;
+  return {
+    title: "Model",
+    description: `The model ${taskName ? `for ${taskName} ` : "to use"}`,
+    ...options,
+    format: semantic,
+    type: "string"
+  };
+}
+function TypeModelByDetail(semantic = "model", options = {}) {
+  if (semantic !== "model" && !semantic.startsWith("model:")) {
+    throw new Error("Invalid semantic value");
+  }
+  return {
+    ...ModelSchema,
+    ...options,
+    format: semantic
+  };
+}
+function TypeModel(semantic = "model", options = {}) {
+  return {
+    oneOf: [TypeModelAsString(semantic, options), TypeModelByDetail(semantic, options)],
+    ...options,
+    format: semantic
+  };
+}
+var TypeReplicateArray = (type, annotations = {}) => ({
+  oneOf: [type, { type: "array", items: type }],
+  title: type.title,
+  description: type.description,
+  ...type.format ? { format: type.format } : {},
+  ...annotations,
+  "x-replicate": true
+});
+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 {
   JobQueueTask,
@@ -565,139 +808,84 @@ class AiTask extends JobQueueTask {
     return input;
   }
 }
-// src/task/base/AiTaskSchemas.ts
-import {
-  FromSchemaDefaultOptions
-} from "@workglow/util";
-var TypedArrayType = null;
-var TypedArraySchemaOptions = {
-  ...FromSchemaDefaultOptions,
-  deserialize: [
-    {
-      pattern: { format: "TypedArray" },
-      output: TypedArrayType
-    }
-  ]
-};
-var TypedArraySchema = (annotations = {}) => ({
-  oneOf: [
-    {
-      type: "array",
-      items: { type: "number", format: "Float64" },
-      title: "Float64Array",
-      description: "A 64-bit floating point array",
-      format: "Float64Array"
-    },
-    {
-      type: "array",
-      items: { type: "number", format: "Float32" },
-      title: "Float32Array",
-      description: "A 32-bit floating point array",
-      format: "Float32Array"
-    },
-    {
-      type: "array",
-      items: { type: "number", format: "Int32" },
-      title: "Int32Array",
-      description: "A 32-bit integer array",
-      format: "Int32Array"
-    },
-    {
-      type: "array",
-      items: { type: "number", format: "Int16" },
-      title: "Int16Array",
-      description: "A 16-bit integer array",
-      format: "Int16Array"
-    },
-    {
-      type: "array",
-      items: { type: "number", format: "Int8" },
-      title: "Int8Array"
-    },
-    {
-      type: "array",
-      items: { type: "number", format: "Uint8" },
-      title: "Uint8Array",
-      description: "A 8-bit unsigned integer array",
-      format: "Uint8Array"
-    },
-    {
-      type: "array",
-      items: { type: "number", format: "Uint16" },
-      title: "Uint16Array",
-      description: "A 16-bit unsigned integer array",
-      format: "Uint16Array"
-    },
-    {
-      type: "array",
-      items: { type: "number", format: "Uint32" },
-      title: "Uint32Array",
-      description: "A 32-bit unsigned integer array",
-      format: "Uint32Array"
-    },
-    {
-      type: "array",
-      items: { type: "number", format: "Uint8Clamped" },
-      title: "Uint8ClampedArray",
-      description: "A 8-bit unsigned integer array with values clamped to 0-255",
-      format: "Uint8ClampedArray"
+
+// 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;
     }
-  ],
-  format: "TypedArray",
-  ...annotations
-});
-var TypeLanguage = (annotations = {}) => ({
-  type: "string",
-  title: "Language",
-  description: "The language to use",
-  maxLength: 2,
-  minLength: 2,
-  ...annotations
-});
-function TypeModelAsString(semantic = "model", options = {}) {
-  if (semantic !== "model" && !semantic.startsWith("model:")) {
-    throw new Error("Invalid semantic value");
+    return jobInput;
   }
-  const taskName = semantic.startsWith("model:") ? semantic.slice(6).replace(/Task$/, "").replaceAll(/[A-Z]/g, (char) => " " + char.toLowerCase()).trim() : null;
-  return {
-    title: "Model",
-    description: `The model ${taskName ? `for ${taskName} ` : "to use"}`,
-    ...options,
-    format: semantic,
-    type: "string"
-  };
 }
-function TypeModelByDetail(semantic = "model", options = {}) {
-  if (semantic !== "model" && !semantic.startsWith("model:")) {
-    throw new Error("Invalid semantic value");
+
+// 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;
   }
-  return {
-    ...ModelSchema,
-    ...options,
-    format: semantic
-  };
-}
-function TypeModel(semantic = "model", options = {}) {
-  return {
-    oneOf: [TypeModelAsString(semantic, options), TypeModelByDetail(semantic, options)],
-    ...options,
-    format: semantic
-  };
 }
-var TypeReplicateArray = (type, annotations = {}) => ({
-  oneOf: [type, { type: "array", items: type }],
-  title: type.title,
-  description: type.description,
-  ...type.format ? { format: type.format } : {},
-  ...annotations,
-  "x-replicate": true
-});
+TaskRegistry.registerTask(BackgroundRemovalTask);
+var BackgroundRemoval = (input, config) => {
+  return new BackgroundRemovalTask(input, config).run();
+};
+Workflow.prototype.BackgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
 // src/task/DocumentSplitterTask.ts
 import {
-  CreateWorkflow,
+  CreateWorkflow as CreateWorkflow2,
   Task,
-  TaskRegistry,
-  Workflow
+  TaskRegistry as TaskRegistry2,
+  Workflow as Workflow2
 } from "@workglow/task-graph";
 var inputSchema = {
   type: "object",
@@ -752,18 +940,18 @@ class DocumentSplitterTask extends Task {
     return { texts: this.flattenFragmentsToTexts(this.runInputData.file) };
   }
 }
-TaskRegistry.registerTask(DocumentSplitterTask);
+TaskRegistry2.registerTask(DocumentSplitterTask);
 var DocumentSplitter = (input) => {
   return new DocumentSplitterTask(input).run();
 };
-Workflow.prototype.DocumentSplitter = CreateWorkflow(DocumentSplitterTask);
+Workflow2.prototype.DocumentSplitter = CreateWorkflow2(DocumentSplitterTask);
 // src/task/DownloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow2, TaskRegistry as TaskRegistry2, Workflow as Workflow2 } from "@workglow/task-graph";
-var modelSchema = TypeReplicateArray(TypeModel("model"));
+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: modelSchema
+    model: modelSchema2
   },
   required: ["model"],
   additionalProperties: false
@@ -771,7 +959,7 @@ var DownloadModelInputSchema = {
 var DownloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema
+    model: modelSchema2
   },
   required: ["model"],
   additionalProperties: false
@@ -811,15 +999,350 @@ class DownloadModelTask extends AiTask {
     }
   }
 }
-TaskRegistry2.registerTask(DownloadModelTask);
+TaskRegistry3.registerTask(DownloadModelTask);
 var DownloadModel = (input, config) => {
   return new DownloadModelTask(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 = {
+Workflow3.prototype.DownloadModel = CreateWorkflow3(DownloadModelTask);
+// src/task/ImageClassificationTask.ts
+import { CreateWorkflow as CreateWorkflow4, TaskRegistry as TaskRegistry4, Workflow as Workflow4 } from "@workglow/task-graph";
+var modelSchema3 = TypeReplicateArray(TypeModel("model:ImageClassificationTask"));
+var ImageClassificationInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema3,
+    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;
+  }
+}
+TaskRegistry4.registerTask(ImageClassificationTask);
+var ImageClassification = (input, config) => {
+  return new ImageClassificationTask(input, config).run();
+};
+Workflow4.prototype.ImageClassification = CreateWorkflow4(ImageClassificationTask);
+// src/task/ImageEmbeddingTask.ts
+import { CreateWorkflow as CreateWorkflow5, TaskRegistry as TaskRegistry5, Workflow as Workflow5 } from "@workglow/task-graph";
+var modelSchema4 = TypeReplicateArray(TypeModel("model:ImageEmbeddingTask"));
+var embeddingSchema = TypedArraySchema({
+  title: "Embedding",
+  description: "The image embedding vector"
+});
+var ImageEmbeddingInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema4
+  },
+  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;
+  }
+}
+TaskRegistry5.registerTask(ImageEmbeddingTask);
+var ImageEmbedding = (input, config) => {
+  return new ImageEmbeddingTask(input, config).run();
+};
+Workflow5.prototype.ImageEmbedding = CreateWorkflow5(ImageEmbeddingTask);
+// src/task/ImageSegmentationTask.ts
+import { CreateWorkflow as CreateWorkflow6, TaskRegistry as TaskRegistry6, Workflow as Workflow6 } from "@workglow/task-graph";
+var modelSchema5 = TypeReplicateArray(TypeModel("model:ImageSegmentationTask"));
+var ImageSegmentationInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema5,
+    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",
+      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: ["label", "score", "mask"],
+  additionalProperties: false
+};
+var ImageSegmentationOutputSchema = {
+  type: "object",
+  properties: {
+    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: ["masks"],
+  additionalProperties: false
+};
+
+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 ImageSegmentationInputSchema;
+  }
+  static outputSchema() {
+    return ImageSegmentationOutputSchema;
+  }
+}
+TaskRegistry6.registerTask(ImageSegmentationTask);
+var ImageSegmentation = (input, config) => {
+  return new ImageSegmentationTask(input, config).run();
+};
+Workflow6.prototype.ImageSegmentation = CreateWorkflow6(ImageSegmentationTask);
+// src/task/ImageToTextTask.ts
+import { CreateWorkflow as CreateWorkflow7, TaskRegistry as TaskRegistry7, Workflow as Workflow7 } from "@workglow/task-graph";
+var modelSchema6 = TypeReplicateArray(TypeModel("model:ImageToTextTask"));
+var generatedTextSchema = {
+  type: "string",
+  title: "Text",
+  description: "The generated text description"
+};
+var ImageToTextInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema6,
+    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;
+  }
+  static outputSchema() {
+    return ImageToTextOutputSchema;
+  }
+}
+TaskRegistry7.registerTask(ImageToTextTask);
+var ImageToText = (input, config) => {
+  return new ImageToTextTask(input, config).run();
+};
+Workflow7.prototype.ImageToText = CreateWorkflow7(ImageToTextTask);
+// src/task/ObjectDetectionTask.ts
+import { CreateWorkflow as CreateWorkflow8, TaskRegistry as TaskRegistry8, Workflow as Workflow8 } from "@workglow/task-graph";
+var modelSchema7 = TypeReplicateArray(TypeModel("model:ObjectDetectionTask"));
+var detectionSchema = {
+  type: "object",
+  properties: {
+    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: ["label", "score", "box"],
+  additionalProperties: false
+};
+var ObjectDetectionInputSchema = {
+  type: "object",
+  properties: {
+    image: TypeReplicateArray(TypeImageInput),
+    model: modelSchema7,
+    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: ["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 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 ObjectDetectionInputSchema;
+  }
+  static outputSchema() {
+    return ObjectDetectionOutputSchema;
+  }
+}
+TaskRegistry8.registerTask(ObjectDetectionTask);
+var ObjectDetection = (input, config) => {
+  return new ObjectDetectionTask(input, config).run();
+};
+Workflow8.prototype.ObjectDetection = CreateWorkflow8(ObjectDetectionTask);
+// src/task/TextClassificationTask.ts
+import { CreateWorkflow as CreateWorkflow9, TaskRegistry as TaskRegistry9, Workflow as Workflow9 } from "@workglow/task-graph";
+var modelSchema8 = TypeReplicateArray(TypeModel("model:TextClassificationTask"));
+var TextClassificationInputSchema = {
   type: "object",
   properties: {
     text: TypeReplicateArray({
@@ -827,20 +1350,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: modelSchema8
   },
   required: ["text", "model"],
   additionalProperties: false
 };
-var TextClassifierOutputSchema = {
+var TextClassificationOutputSchema = {
   type: "object",
   properties: {
     categories: {
@@ -870,26 +1403,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();
+TaskRegistry9.registerTask(TextClassificationTask);
+var TextClassification = (input, config) => {
+  return new TextClassificationTask(input, config).run();
 };
-Workflow3.prototype.TextClassifier = CreateWorkflow3(TextClassifierTask);
+Workflow9.prototype.TextClassification = CreateWorkflow9(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 CreateWorkflow10, TaskRegistry as TaskRegistry10, Workflow as Workflow10 } from "@workglow/task-graph";
+var modelSchema9 = TypeReplicateArray(TypeModel("model:TextEmbeddingTask"));
 var TextEmbeddingInputSchema = {
   type: "object",
   properties: {
@@ -898,7 +1431,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema3
+    model: modelSchema9
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -927,14 +1460,14 @@ class TextEmbeddingTask extends AiTask {
     return TextEmbeddingOutputSchema;
   }
 }
-TaskRegistry4.registerTask(TextEmbeddingTask);
+TaskRegistry10.registerTask(TextEmbeddingTask);
 var TextEmbedding = async (input, config) => {
   return new TextEmbeddingTask(input, config).run();
 };
-Workflow4.prototype.TextEmbedding = CreateWorkflow4(TextEmbeddingTask);
+Workflow10.prototype.TextEmbedding = CreateWorkflow10(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 CreateWorkflow11, TaskRegistry as TaskRegistry11, Workflow as Workflow11 } from "@workglow/task-graph";
+var modelSchema10 = TypeReplicateArray(TypeModel("model:TextFillMaskTask"));
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -943,7 +1476,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     }),
-    model: modelSchema4
+    model: modelSchema10
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -986,8 +1519,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 +1528,23 @@ class TextFillMaskTask extends AiTask {
     return TextFillMaskOutputSchema;
   }
 }
-TaskRegistry5.registerTask(TextFillMaskTask);
+TaskRegistry11.registerTask(TextFillMaskTask);
 var TextFillMask = (input, config) => {
   return new TextFillMaskTask(input, config).run();
 };
-Workflow5.prototype.TextFillMask = CreateWorkflow5(TextFillMaskTask);
+Workflow11.prototype.TextFillMask = CreateWorkflow11(TextFillMaskTask);
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow6, TaskRegistry as TaskRegistry6, Workflow as Workflow6 } from "@workglow/task-graph";
-var generatedTextSchema = {
+import { CreateWorkflow as CreateWorkflow12, TaskRegistry as TaskRegistry12, Workflow as Workflow12 } from "@workglow/task-graph";
+var generatedTextSchema2 = {
   type: "string",
   title: "Text",
   description: "The generated text"
 };
-var modelSchema5 = TypeReplicateArray(TypeModel("model:TextGenerationTask"));
+var modelSchema11 = TypeReplicateArray(TypeModel("model:TextGenerationTask"));
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema5,
+    model: modelSchema11,
     prompt: TypeReplicateArray({
       type: "string",
       title: "Prompt",
@@ -1065,9 +1598,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 +1619,14 @@ class TextGenerationTask extends AiTask {
     return TextGenerationOutputSchema;
   }
 }
-TaskRegistry6.registerTask(TextGenerationTask);
+TaskRegistry12.registerTask(TextGenerationTask);
 var TextGeneration = (input, config) => {
   return new TextGenerationTask(input, config).run();
 };
-Workflow6.prototype.TextGeneration = CreateWorkflow6(TextGenerationTask);
+Workflow12.prototype.TextGeneration = CreateWorkflow12(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 CreateWorkflow13, TaskRegistry as TaskRegistry13, Workflow as Workflow13 } from "@workglow/task-graph";
+var modelSchema12 = TypeReplicateArray(TypeModel("model:TextLanguageDetectionTask"));
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -1110,7 +1643,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema6
+    model: modelSchema12
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1157,14 +1690,14 @@ class TextLanguageDetectionTask extends AiTask {
     return TextLanguageDetectionOutputSchema;
   }
 }
-TaskRegistry7.registerTask(TextLanguageDetectionTask);
+TaskRegistry13.registerTask(TextLanguageDetectionTask);
 var TextLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(input, config).run();
 };
-Workflow7.prototype.TextLanguageDetection = CreateWorkflow7(TextLanguageDetectionTask);
+Workflow13.prototype.TextLanguageDetection = CreateWorkflow13(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 CreateWorkflow14, TaskRegistry as TaskRegistry14, Workflow as Workflow14 } from "@workglow/task-graph";
+var modelSchema13 = TypeReplicateArray(TypeModel("model:NamedEntityRecognitionTask"));
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
   properties: {
@@ -1183,7 +1716,7 @@ var TextNamedEntityRecognitionInputSchema = {
       "x-ui-group": "Configuration",
       "x-ui-group-open": false
     },
-    model: modelSchema7
+    model: modelSchema13
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1226,8 +1759,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 +1768,13 @@ class TextNamedEntityRecognitionTask extends AiTask {
     return TextNamedEntityRecognitionOutputSchema;
   }
 }
-TaskRegistry8.registerTask(TextNamedEntityRecognitionTask);
+TaskRegistry14.registerTask(TextNamedEntityRecognitionTask);
 var TextNamedEntityRecognition = (input, config) => {
   return new TextNamedEntityRecognitionTask(input, config).run();
 };
-Workflow8.prototype.TextNamedEntityRecognition = CreateWorkflow8(TextNamedEntityRecognitionTask);
+Workflow14.prototype.TextNamedEntityRecognition = CreateWorkflow14(TextNamedEntityRecognitionTask);
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow9, TaskRegistry as TaskRegistry9, Workflow as Workflow9 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow15, TaskRegistry as TaskRegistry15, Workflow as Workflow15 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -1257,13 +1790,13 @@ var textSchema = {
   title: "Text",
   description: "The generated text"
 };
-var modelSchema8 = TypeReplicateArray(TypeModel("model:TextQuestionAnswerTask"));
+var modelSchema14 = TypeReplicateArray(TypeModel("model:TextQuestionAnswerTask"));
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: TypeReplicateArray(contextSchema),
     question: TypeReplicateArray(questionSchema),
-    model: modelSchema8
+    model: modelSchema14
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -1293,14 +1826,14 @@ class TextQuestionAnswerTask extends AiTask {
     return TextQuestionAnswerOutputSchema;
   }
 }
-TaskRegistry9.registerTask(TextQuestionAnswerTask);
+TaskRegistry15.registerTask(TextQuestionAnswerTask);
 var TextQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(input, config).run();
 };
-Workflow9.prototype.TextQuestionAnswer = CreateWorkflow9(TextQuestionAnswerTask);
+Workflow15.prototype.TextQuestionAnswer = CreateWorkflow15(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 CreateWorkflow16, TaskRegistry as TaskRegistry16, Workflow as Workflow16 } from "@workglow/task-graph";
+var modelSchema15 = TypeReplicateArray(TypeModel("model:TextRewriterTask"));
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -1314,7 +1847,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     }),
-    model: modelSchema9
+    model: modelSchema15
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -1344,14 +1877,14 @@ class TextRewriterTask extends AiTask {
     return TextRewriterOutputSchema;
   }
 }
-TaskRegistry10.registerTask(TextRewriterTask);
+TaskRegistry16.registerTask(TextRewriterTask);
 var TextRewriter = (input, config) => {
   return new TextRewriterTask(input, config).run();
 };
-Workflow10.prototype.TextRewriter = CreateWorkflow10(TextRewriterTask);
+Workflow16.prototype.TextRewriter = CreateWorkflow16(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 CreateWorkflow17, TaskRegistry as TaskRegistry17, Workflow as Workflow17 } from "@workglow/task-graph";
+var modelSchema16 = TypeReplicateArray(TypeModel("model:TextSummaryTask"));
 var TextSummaryInputSchema = {
   type: "object",
   properties: {
@@ -1360,7 +1893,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     }),
-    model: modelSchema10
+    model: modelSchema16
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1390,14 +1923,14 @@ class TextSummaryTask extends AiTask {
     return TextSummaryOutputSchema;
   }
 }
-TaskRegistry11.registerTask(TextSummaryTask);
+TaskRegistry17.registerTask(TextSummaryTask);
 var TextSummary = async (input, config) => {
   return new TextSummaryTask(input, config).run();
 };
-Workflow11.prototype.TextSummary = CreateWorkflow11(TextSummaryTask);
+Workflow17.prototype.TextSummary = CreateWorkflow17(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 CreateWorkflow18, TaskRegistry as TaskRegistry18, Workflow as Workflow18 } from "@workglow/task-graph";
+var modelSchema17 = TypeReplicateArray(TypeModel("model:TextTranslationTask"));
 var translationTextSchema = {
   type: "string",
   title: "Text",
@@ -1423,7 +1956,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     })),
-    model: modelSchema11
+    model: modelSchema17
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -1459,18 +1992,18 @@ class TextTranslationTask extends AiTask {
     return TextTranslationOutputSchema;
   }
 }
-TaskRegistry12.registerTask(TextTranslationTask);
+TaskRegistry18.registerTask(TextTranslationTask);
 var TextTranslation = (input, config) => {
   return new TextTranslationTask(input, config).run();
 };
-Workflow12.prototype.TextTranslation = CreateWorkflow12(TextTranslationTask);
+Workflow18.prototype.TextTranslation = CreateWorkflow18(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 CreateWorkflow19, TaskRegistry as TaskRegistry19, Workflow as Workflow19 } from "@workglow/task-graph";
+var modelSchema18 = TypeReplicateArray(TypeModel("model"));
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema12
+    model: modelSchema18
   },
   required: ["model"],
   additionalProperties: false
@@ -1478,7 +2011,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema12
+    model: modelSchema18
   },
   required: ["model"],
   additionalProperties: false
@@ -1497,18 +2030,18 @@ class UnloadModelTask extends AiTask {
   }
   static cacheable = false;
 }
-TaskRegistry13.registerTask(UnloadModelTask);
+TaskRegistry19.registerTask(UnloadModelTask);
 var UnloadModel = (input, config) => {
   return new UnloadModelTask(input, config).run();
 };
-Workflow13.prototype.UnloadModel = CreateWorkflow13(UnloadModelTask);
+Workflow19.prototype.UnloadModel = CreateWorkflow19(UnloadModelTask);
 // src/task/VectorSimilarityTask.ts
 import {
   ArrayTask,
-  CreateWorkflow as CreateWorkflow14,
+  CreateWorkflow as CreateWorkflow20,
   TaskError,
-  TaskRegistry as TaskRegistry14,
-  Workflow as Workflow14
+  TaskRegistry as TaskRegistry20,
+  Workflow as Workflow20
 } from "@workglow/task-graph";
 var SimilarityFn = {
   COSINE: "cosine",
@@ -1602,11 +2135,11 @@ class VectorSimilarityTask extends ArrayTask {
     };
   }
 }
-TaskRegistry14.registerTask(VectorSimilarityTask);
+TaskRegistry20.registerTask(VectorSimilarityTask);
 var Similarity = (input, config) => {
   return new VectorSimilarityTask(input, config).run();
 };
-Workflow14.prototype.Similarity = CreateWorkflow14(VectorSimilarityTask);
+Workflow20.prototype.Similarity = CreateWorkflow20(VectorSimilarityTask);
 function inner(arr1, arr2) {
   return 1 - arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
 }
@@ -1650,6 +2183,10 @@ export {
   TypeModelAsString,
   TypeModel,
   TypeLanguage,
+  TypeImageInput,
+  TypeCategory,
+  TypeBoundingBox,
+  TypeAudioInput,
   TextTranslationTask,
   TextTranslationOutputSchema,
   TextTranslationInputSchema,
@@ -1687,19 +2224,39 @@ export {
   TextEmbeddingOutputSchema,
   TextEmbeddingInputSchema,
   TextEmbedding,
-  TextClassifierTask,
-  TextClassifierOutputSchema,
-  TextClassifierInputSchema,
-  TextClassifier,
+  TextClassificationTask,
+  TextClassificationOutputSchema,
+  TextClassificationInputSchema,
+  TextClassification,
   TableFragment,
   SimilarityFn,
   Similarity,
+  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,
   DownloadModelTask,
   DownloadModel,
   DocumentSplitterTask,
@@ -1709,9 +2266,13 @@ export {
   DocumentConverterMarkdown,
   DocumentBaseFragment,
   Document,
+  BackgroundRemovalTask,
+  BackgroundRemovalOutputSchema,
+  BackgroundRemovalInputSchema,
+  BackgroundRemoval,
   AiTask,
   AiProviderRegistry,
   AiJob
 };
 
-//# debugId=B028A393AC9B8DFF64756E2164756E21
+//# debugId=7B9E2A3103106B9D64756E2164756E21