@workglow/ai 0.0.70 → 0.0.72

package/dist/browser.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,12 +576,316 @@ var TypeReplicateArray = (type, annotations = {}) => ({
   ...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,
+  TaskConfigurationError
+} from "@workglow/task-graph";
+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,
+  CreateWorkflow as CreateWorkflow2,
   Task,
-  TaskRegistry,
-  Workflow
+  TaskRegistry as TaskRegistry2,
+  Workflow as Workflow2
 } from "@workglow/task-graph";
 var inputSchema = {
   type: "object",
@@ -709,117 +897,452 @@ var inputSchema = {
       description: "The kind of document (txt or md)"
     }
   },
-  required: ["parser"],
+  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/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 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];
+}
+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;
   }
-  async executeReactive() {
-    return { texts: this.flattenFragmentsToTexts(this.runInputData.file) };
+  static outputSchema() {
+    return ImageToTextOutputSchema;
   }
 }
-TaskRegistry.registerTask(DocumentSplitterTask);
-var DocumentSplitter = (input) => {
-  return new DocumentSplitterTask(input).run();
+TaskRegistry7.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 = {
+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: {
-    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: 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: ["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 = [];
-    });
-  }
-  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;
-    }
+    return ObjectDetectionOutputSchema;
   }
 }
-TaskRegistry2.registerTask(DownloadModelTask);
-var DownloadModel = (input, config) => {
-  return new DownloadModelTask(input, config).run();
+TaskRegistry8.registerTask(ObjectDetectionTask);
+var ObjectDetection = (input, config) => {
+  return new ObjectDetectionTask(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 = {
+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,26 +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: {
-      oneOf: [
-        {
-          type: "number",
-          minimum: 1,
-          maximum: 1000
-        },
-        {
-          type: "null"
-        }
-      ],
+      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: {
@@ -876,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: {
@@ -904,7 +1431,7 @@ var TextEmbeddingInputSchema = {
       title: "Text",
       description: "The text to embed"
     }),
-    model: modelSchema3
+    model: modelSchema9
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -933,23 +1460,91 @@ 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 CreateWorkflow11, TaskRegistry as TaskRegistry11, Workflow as Workflow11 } from "@workglow/task-graph";
+var modelSchema10 = TypeReplicateArray(TypeModel("model:TextFillMaskTask"));
+var TextFillMaskInputSchema = {
+  type: "object",
+  properties: {
+    text: TypeReplicateArray({
+      type: "string",
+      title: "Text",
+      description: "The text with a mask token to fill"
+    }),
+    model: modelSchema10
+  },
+  required: ["text", "model"],
+  additionalProperties: false
+};
+var TextFillMaskOutputSchema = {
+  type: "object",
+  properties: {
+    predictions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          entity: {
+            type: "string",
+            title: "Entity",
+            description: "The token that was predicted to fill the mask"
+          },
+          score: {
+            type: "number",
+            title: "Score",
+            description: "The confidence score for this prediction"
+          },
+          sequence: {
+            type: "string",
+            title: "Sequence",
+            description: "The complete text with the mask filled"
+          }
+        },
+        required: ["entity", "score", "sequence"],
+        additionalProperties: false
+      },
+      title: "Predictions",
+      description: "The predicted tokens to fill the mask with their scores and complete sequences"
+    }
+  },
+  required: ["predictions"],
+  additionalProperties: false
+};
+
+class TextFillMaskTask extends AiTask {
+  static type = "TextFillMaskTask";
+  static category = "AI Text Model";
+  static title = "Fill Mask";
+  static description = "Fills masked tokens in text";
+  static inputSchema() {
+    return TextFillMaskInputSchema;
+  }
+  static outputSchema() {
+    return TextFillMaskOutputSchema;
+  }
+}
+TaskRegistry11.registerTask(TextFillMaskTask);
+var TextFillMask = (input, config) => {
+  return new TextFillMaskTask(input, config).run();
+};
+Workflow11.prototype.TextFillMask = CreateWorkflow11(TextFillMaskTask);
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow5, TaskRegistry as TaskRegistry5, Workflow as Workflow5 } 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 modelSchema4 = TypeReplicateArray(TypeModel("model:TextGenerationTask"));
+var modelSchema11 = TypeReplicateArray(TypeModel("model:TextGenerationTask"));
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema4,
+    model: modelSchema11,
     prompt: TypeReplicateArray({
       type: "string",
       title: "Prompt",
@@ -1003,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"],
@@ -1024,14 +1619,14 @@ class TextGenerationTask extends AiTask {
     return TextGenerationOutputSchema;
   }
 }
-TaskRegistry5.registerTask(TextGenerationTask);
+TaskRegistry12.registerTask(TextGenerationTask);
 var TextGeneration = (input, config) => {
   return new TextGenerationTask(input, config).run();
 };
-Workflow5.prototype.TextGeneration = CreateWorkflow5(TextGenerationTask);
+Workflow12.prototype.TextGeneration = CreateWorkflow12(TextGenerationTask);
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow6, TaskRegistry as TaskRegistry6, Workflow as Workflow6 } from "@workglow/task-graph";
-var modelSchema5 = 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: {
@@ -1041,20 +1636,14 @@ var TextLanguageDetectionInputSchema = {
       description: "The text to detect the language of"
     }),
     maxLanguages: {
-      oneOf: [
-        {
-          type: "number",
-          minimum: 1,
-          maximum: 1000
-        },
-        {
-          type: "null"
-        }
-      ],
+      type: "number",
+      minimum: 0,
+      maximum: 100,
+      default: 5,
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema5
+    model: modelSchema12
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1101,13 +1690,91 @@ class TextLanguageDetectionTask extends AiTask {
     return TextLanguageDetectionOutputSchema;
   }
 }
-TaskRegistry6.registerTask(TextLanguageDetectionTask);
+TaskRegistry13.registerTask(TextLanguageDetectionTask);
 var TextLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(input, config).run();
 };
-Workflow6.prototype.TextLanguageDetection = CreateWorkflow6(TextLanguageDetectionTask);
+Workflow13.prototype.TextLanguageDetection = CreateWorkflow13(TextLanguageDetectionTask);
+// src/task/TextNamedEntityRecognitionTask.ts
+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: {
+    text: TypeReplicateArray({
+      type: "string",
+      title: "Text",
+      description: "The text to extract named entities from"
+    }),
+    blockList: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      title: "Block List",
+      description: "The entity types to exclude from results",
+      "x-ui-group": "Configuration",
+      "x-ui-group-open": false
+    },
+    model: modelSchema13
+  },
+  required: ["text", "model"],
+  additionalProperties: false
+};
+var TextNamedEntityRecognitionOutputSchema = {
+  type: "object",
+  properties: {
+    entities: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          entity: {
+            type: "string",
+            title: "Entity",
+            description: "The type of the named entity"
+          },
+          score: {
+            type: "number",
+            title: "Score",
+            description: "The confidence score for this entity"
+          },
+          word: {
+            type: "string",
+            title: "Word",
+            description: "The extracted text of the named entity"
+          }
+        },
+        required: ["entity", "score", "word"],
+        additionalProperties: false
+      },
+      title: "Entities",
+      description: "The extracted named entities with their types, scores, and text"
+    }
+  },
+  required: ["entities"],
+  additionalProperties: false
+};
+
+class TextNamedEntityRecognitionTask extends AiTask {
+  static type = "TextNamedEntityRecognitionTask";
+  static category = "AI Text Model";
+  static title = "Named Entity Recognition";
+  static description = "Extracts named entities from text";
+  static inputSchema() {
+    return TextNamedEntityRecognitionInputSchema;
+  }
+  static outputSchema() {
+    return TextNamedEntityRecognitionOutputSchema;
+  }
+}
+TaskRegistry14.registerTask(TextNamedEntityRecognitionTask);
+var TextNamedEntityRecognition = (input, config) => {
+  return new TextNamedEntityRecognitionTask(input, config).run();
+};
+Workflow14.prototype.TextNamedEntityRecognition = CreateWorkflow14(TextNamedEntityRecognitionTask);
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow7, TaskRegistry as TaskRegistry7, Workflow as Workflow7 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow15, TaskRegistry as TaskRegistry15, Workflow as Workflow15 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -1123,13 +1790,13 @@ var textSchema = {
   title: "Text",
   description: "The generated text"
 };
-var modelSchema6 = TypeReplicateArray(TypeModel("model:TextQuestionAnswerTask"));
+var modelSchema14 = TypeReplicateArray(TypeModel("model:TextQuestionAnswerTask"));
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: TypeReplicateArray(contextSchema),
     question: TypeReplicateArray(questionSchema),
-    model: modelSchema6
+    model: modelSchema14
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -1159,14 +1826,14 @@ class TextQuestionAnswerTask extends AiTask {
     return TextQuestionAnswerOutputSchema;
   }
 }
-TaskRegistry7.registerTask(TextQuestionAnswerTask);
+TaskRegistry15.registerTask(TextQuestionAnswerTask);
 var TextQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(input, config).run();
 };
-Workflow7.prototype.TextQuestionAnswer = CreateWorkflow7(TextQuestionAnswerTask);
+Workflow15.prototype.TextQuestionAnswer = CreateWorkflow15(TextQuestionAnswerTask);
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow8, TaskRegistry as TaskRegistry8, Workflow as Workflow8 } from "@workglow/task-graph";
-var modelSchema7 = 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: {
@@ -1180,7 +1847,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     }),
-    model: modelSchema7
+    model: modelSchema15
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -1210,14 +1877,14 @@ class TextRewriterTask extends AiTask {
     return TextRewriterOutputSchema;
   }
 }
-TaskRegistry8.registerTask(TextRewriterTask);
+TaskRegistry16.registerTask(TextRewriterTask);
 var TextRewriter = (input, config) => {
   return new TextRewriterTask(input, config).run();
 };
-Workflow8.prototype.TextRewriter = CreateWorkflow8(TextRewriterTask);
+Workflow16.prototype.TextRewriter = CreateWorkflow16(TextRewriterTask);
 // src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow9, TaskRegistry as TaskRegistry9, Workflow as Workflow9 } from "@workglow/task-graph";
-var modelSchema8 = 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: {
@@ -1226,7 +1893,7 @@ var TextSummaryInputSchema = {
       title: "Text",
       description: "The text to summarize"
     }),
-    model: modelSchema8
+    model: modelSchema16
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -1256,14 +1923,14 @@ class TextSummaryTask extends AiTask {
     return TextSummaryOutputSchema;
   }
 }
-TaskRegistry9.registerTask(TextSummaryTask);
+TaskRegistry17.registerTask(TextSummaryTask);
 var TextSummary = async (input, config) => {
   return new TextSummaryTask(input, config).run();
 };
-Workflow9.prototype.TextSummary = CreateWorkflow9(TextSummaryTask);
+Workflow17.prototype.TextSummary = CreateWorkflow17(TextSummaryTask);
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow10, TaskRegistry as TaskRegistry10, Workflow as Workflow10 } from "@workglow/task-graph";
-var modelSchema9 = 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",
@@ -1289,7 +1956,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     })),
-    model: modelSchema9
+    model: modelSchema17
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -1325,18 +1992,18 @@ class TextTranslationTask extends AiTask {
     return TextTranslationOutputSchema;
   }
 }
-TaskRegistry10.registerTask(TextTranslationTask);
+TaskRegistry18.registerTask(TextTranslationTask);
 var TextTranslation = (input, config) => {
   return new TextTranslationTask(input, config).run();
 };
-Workflow10.prototype.TextTranslation = CreateWorkflow10(TextTranslationTask);
+Workflow18.prototype.TextTranslation = CreateWorkflow18(TextTranslationTask);
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow11, TaskRegistry as TaskRegistry11, Workflow as Workflow11 } from "@workglow/task-graph";
-var modelSchema10 = 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: modelSchema10
+    model: modelSchema18
   },
   required: ["model"],
   additionalProperties: false
@@ -1344,7 +2011,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema10
+    model: modelSchema18
   },
   required: ["model"],
   additionalProperties: false
@@ -1363,18 +2030,18 @@ class UnloadModelTask extends AiTask {
   }
   static cacheable = false;
 }
-TaskRegistry11.registerTask(UnloadModelTask);
+TaskRegistry19.registerTask(UnloadModelTask);
 var UnloadModel = (input, config) => {
   return new UnloadModelTask(input, config).run();
 };
-Workflow11.prototype.UnloadModel = CreateWorkflow11(UnloadModelTask);
+Workflow19.prototype.UnloadModel = CreateWorkflow19(UnloadModelTask);
 // src/task/VectorSimilarityTask.ts
 import {
   ArrayTask,
-  CreateWorkflow as CreateWorkflow12,
+  CreateWorkflow as CreateWorkflow20,
   TaskError,
-  TaskRegistry as TaskRegistry12,
-  Workflow as Workflow12
+  TaskRegistry as TaskRegistry20,
+  Workflow as Workflow20
 } from "@workglow/task-graph";
 var SimilarityFn = {
   COSINE: "cosine",
@@ -1468,11 +2135,11 @@ class VectorSimilarityTask extends ArrayTask {
     };
   }
 }
-TaskRegistry12.registerTask(VectorSimilarityTask);
+TaskRegistry20.registerTask(VectorSimilarityTask);
 var Similarity = (input, config) => {
   return new VectorSimilarityTask(input, config).run();
 };
-Workflow12.prototype.Similarity = CreateWorkflow12(VectorSimilarityTask);
+Workflow20.prototype.Similarity = CreateWorkflow20(VectorSimilarityTask);
 function inner(arr1, arr2) {
   return 1 - arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
 }
@@ -1516,6 +2183,10 @@ export {
   TypeModelAsString,
   TypeModel,
   TypeLanguage,
+  TypeImageInput,
+  TypeCategory,
+  TypeBoundingBox,
+  TypeAudioInput,
   TextTranslationTask,
   TextTranslationOutputSchema,
   TextTranslationInputSchema,
@@ -1532,6 +2203,10 @@ export {
   TextQuestionAnswerOutputSchema,
   TextQuestionAnswerInputSchema,
   TextQuestionAnswer,
+  TextNamedEntityRecognitionTask,
+  TextNamedEntityRecognitionOutputSchema,
+  TextNamedEntityRecognitionInputSchema,
+  TextNamedEntityRecognition,
   TextLanguageDetectionTask,
   TextLanguageDetectionOutputSchema,
   TextLanguageDetectionInputSchema,
@@ -1541,23 +2216,47 @@ export {
   TextGenerationInputSchema,
   TextGeneration,
   TextFragment,
+  TextFillMaskTask,
+  TextFillMaskOutputSchema,
+  TextFillMaskInputSchema,
+  TextFillMask,
   TextEmbeddingTask,
   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,
@@ -1567,9 +2266,13 @@ export {
   DocumentConverterMarkdown,
   DocumentBaseFragment,
   Document,
+  BackgroundRemovalTask,
+  BackgroundRemovalOutputSchema,
+  BackgroundRemovalInputSchema,
+  BackgroundRemoval,
   AiTask,
   AiProviderRegistry,
   AiJob
 };
 
-//# debugId=7179DF21BC09BC6364756E2164756E21
+//# debugId=7B9E2A3103106B9D64756E2164756E21