@workglow/ai 0.0.78 → 0.0.80

package/dist/bun.js

@@ -7,9 +7,82 @@ import {
   PermanentJobError
 } from "@workglow/job-queue";
 
-// src/model/ModelRegistry.ts
-import { createServiceToken, globalServiceRegistry } from "@workglow/util";
+// src/provider/AiProviderRegistry.ts
+import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util";
+
+class AiProviderRegistry {
+  runFnRegistry = new Map;
+  registerRunFn(modelProvider, taskType, runFn) {
+    if (!this.runFnRegistry.has(taskType)) {
+      this.runFnRegistry.set(taskType, new Map);
+    }
+    this.runFnRegistry.get(taskType).set(modelProvider, runFn);
+  }
+  registerAsWorkerRunFn(modelProvider, taskType) {
+    const workerFn = async (input, model, update_progress, signal) => {
+      const workerManager = globalServiceRegistry.get(WORKER_MANAGER);
+      const result = await workerManager.callWorkerFunction(modelProvider, taskType, [input, model], {
+        signal,
+        onProgress: update_progress
+      });
+      return result;
+    };
+    this.registerRunFn(modelProvider, taskType, workerFn);
+  }
+  getDirectRunFn(modelProvider, taskType) {
+    const taskTypeMap = this.runFnRegistry.get(taskType);
+    const runFn = taskTypeMap?.get(modelProvider);
+    if (!runFn) {
+      throw new Error(`No run function found for task type ${taskType} and model provider ${modelProvider}`);
+    }
+    return runFn;
+  }
+}
+var providerRegistry;
+function getAiProviderRegistry() {
+  if (!providerRegistry)
+    providerRegistry = new AiProviderRegistry;
+  return providerRegistry;
+}
+function setAiProviderRegistry(pr) {
+  providerRegistry = pr;
+}
 
+// src/job/AiJob.ts
+class AiJob extends Job {
+  async execute(input, context) {
+    if (context.signal.aborted || this.status === JobStatus.ABORTING) {
+      throw new AbortSignalJobError("Abort signal aborted before execution of job");
+    }
+    let abortHandler;
+    try {
+      const abortPromise = new Promise((_resolve, reject) => {
+        const handler = () => {
+          reject(new AbortSignalJobError("Abort signal seen, ending job"));
+        };
+        context.signal.addEventListener("abort", handler, { once: true });
+        abortHandler = () => context.signal.removeEventListener("abort", handler);
+      });
+      const runFn = async () => {
+        const fn = getAiProviderRegistry().getDirectRunFn(input.aiProvider, input.taskType);
+        if (!fn) {
+          throw new PermanentJobError(`No run function found for task type ${input.taskType} and model provider ${input.aiProvider}`);
+        }
+        const model = input.taskInput.model;
+        if (context.signal?.aborted) {
+          throw new AbortSignalJobError("Job aborted");
+        }
+        return await fn(input.taskInput, model, context.updateProgress, context.signal);
+      };
+      const runFnPromise = runFn();
+      return await Promise.race([runFnPromise, abortPromise]);
+    } finally {
+      if (abortHandler) {
+        abortHandler();
+      }
+    }
+  }
+}
 // src/model/InMemoryModelRepository.ts
 import { InMemoryTabularRepository } from "@workglow/storage";
 
@@ -93,7 +166,7 @@ class ModelRepository {
 }
 
 // src/model/ModelSchema.ts
-var ModelSchema = {
+var ModelConfigSchema = {
   type: "object",
   properties: {
     model_id: { type: "string" },
@@ -104,6 +177,15 @@ var ModelSchema = {
     providerConfig: { type: "object", default: {} },
     metadata: { type: "object", default: {} }
   },
+  required: ["provider", "providerConfig"],
+  format: "model",
+  additionalProperties: false
+};
+var ModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties
+  },
   required: ["model_id", "tasks", "provider", "title", "description", "providerConfig", "metadata"],
   format: "model",
   additionalProperties: false
@@ -113,101 +195,20 @@ var ModelPrimaryKeyNames = ["model_id"];
 // src/model/InMemoryModelRepository.ts
 class InMemoryModelRepository extends ModelRepository {
   constructor() {
-    super(new InMemoryTabularRepository(ModelSchema, ModelPrimaryKeyNames));
+    super(new InMemoryTabularRepository(ModelRecordSchema, ModelPrimaryKeyNames));
   }
 }
-
 // src/model/ModelRegistry.ts
+import { createServiceToken, globalServiceRegistry as globalServiceRegistry2 } from "@workglow/util";
 var MODEL_REPOSITORY = createServiceToken("model.repository");
-if (!globalServiceRegistry.has(MODEL_REPOSITORY)) {
-  globalServiceRegistry.register(MODEL_REPOSITORY, () => new InMemoryModelRepository, true);
+if (!globalServiceRegistry2.has(MODEL_REPOSITORY)) {
+  globalServiceRegistry2.register(MODEL_REPOSITORY, () => new InMemoryModelRepository, true);
 }
 function getGlobalModelRepository() {
-  return globalServiceRegistry.get(MODEL_REPOSITORY);
+  return globalServiceRegistry2.get(MODEL_REPOSITORY);
 }
 function setGlobalModelRepository(pr) {
-  globalServiceRegistry.registerInstance(MODEL_REPOSITORY, pr);
-}
-
-// src/provider/AiProviderRegistry.ts
-import { globalServiceRegistry as globalServiceRegistry2, WORKER_MANAGER } from "@workglow/util";
-
-class AiProviderRegistry {
-  runFnRegistry = new Map;
-  registerRunFn(modelProvider, taskType, runFn) {
-    if (!this.runFnRegistry.has(taskType)) {
-      this.runFnRegistry.set(taskType, new Map);
-    }
-    this.runFnRegistry.get(taskType).set(modelProvider, runFn);
-  }
-  registerAsWorkerRunFn(modelProvider, taskType) {
-    const workerFn = async (input, model, update_progress, signal) => {
-      const workerManager = globalServiceRegistry2.get(WORKER_MANAGER);
-      const result = await workerManager.callWorkerFunction(modelProvider, taskType, [input, model], {
-        signal,
-        onProgress: update_progress
-      });
-      return result;
-    };
-    this.registerRunFn(modelProvider, taskType, workerFn);
-  }
-  getDirectRunFn(modelProvider, taskType) {
-    const taskTypeMap = this.runFnRegistry.get(taskType);
-    const runFn = taskTypeMap?.get(modelProvider);
-    if (!runFn) {
-      throw new Error(`No run function found for task type ${taskType} and model provider ${modelProvider}`);
-    }
-    return runFn;
-  }
-}
-var providerRegistry;
-function getAiProviderRegistry() {
-  if (!providerRegistry)
-    providerRegistry = new AiProviderRegistry;
-  return providerRegistry;
-}
-function setAiProviderRegistry(pr) {
-  providerRegistry = pr;
-}
-
-// src/job/AiJob.ts
-class AiJob extends Job {
-  async execute(input, context) {
-    if (context.signal.aborted || this.status === JobStatus.ABORTING) {
-      throw new AbortSignalJobError("Abort signal aborted before execution of job");
-    }
-    let abortHandler;
-    try {
-      const abortPromise = new Promise((_resolve, reject) => {
-        const handler = () => {
-          reject(new AbortSignalJobError("Abort signal seen, ending job"));
-        };
-        context.signal.addEventListener("abort", handler, { once: true });
-        abortHandler = () => context.signal.removeEventListener("abort", handler);
-      });
-      const runFn = async () => {
-        const fn = getAiProviderRegistry().getDirectRunFn(input.aiProvider, input.taskType);
-        if (!fn) {
-          throw new PermanentJobError(`No run function found for task type ${input.taskType} and model provider ${input.aiProvider}`);
-        }
-        const modelName = input.taskInput.model;
-        const model = await getGlobalModelRepository().findByName(modelName);
-        if (modelName && !model) {
-          throw new PermanentJobError(`Model ${modelName} not found`);
-        }
-        if (context.signal?.aborted) {
-          throw new AbortSignalJobError("Job aborted");
-        }
-        return await fn(input.taskInput, model, context.updateProgress, context.signal);
-      };
-      const runFnPromise = runFn();
-      return await Promise.race([runFnPromise, abortPromise]);
-    } finally {
-      if (abortHandler) {
-        abortHandler();
-      }
-    }
-  }
+  globalServiceRegistry2.registerInstance(MODEL_REPOSITORY, pr);
 }
 // src/source/Document.ts
 class Document {
@@ -557,7 +558,7 @@ function TypeModelByDetail(semantic = "model", options = {}) {
     throw new Error("Invalid semantic value");
   }
   return {
-    ...ModelSchema,
+    ...ModelConfigSchema,
     ...options,
     format: semantic
   };
@@ -706,22 +707,44 @@ 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 : ""}`;
+    const modelLabel = typeof input.model === "string" ? input.model : Array.isArray(input.model) ? undefined : typeof input.model === "object" && input.model ? input.model.model_id || input.model.title || input.model.provider : undefined;
+    config.name ||= `${new.target.type || new.target.name}${modelLabel ? " with model " + modelLabel : ""}`;
     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");
+    if (Array.isArray(input.model)) {
+      console.error("AiTask: Model is an array", input);
+      throw new TaskConfigurationError("AiTask: Model is an array, only create job for single model tasks");
     }
     const runtype = this.constructor.runtype ?? this.constructor.type;
-    const model = await this.getModelForInput(input);
+    const model = await this.getModelConfigForInput(input);
     return {
       taskType: runtype,
       aiProvider: model.provider,
-      taskInput: input
+      taskInput: { ...input, model }
     };
   }
+  async getModelConfigForInput(input) {
+    const modelValue = input.model;
+    if (!modelValue)
+      throw new TaskConfigurationError("AiTask: No model found");
+    if (typeof modelValue === "string") {
+      const modelname = modelValue;
+      if (this.modelCache && this.modelCache.name === modelname) {
+        return this.modelCache.model;
+      }
+      const model = await getGlobalModelRepository().findByName(modelname);
+      if (!model) {
+        throw new TaskConfigurationError(`AiTask: No model ${modelname} found`);
+      }
+      this.modelCache = { name: modelname, model };
+      return model;
+    }
+    if (typeof modelValue === "object") {
+      return modelValue;
+    }
+    throw new TaskConfigurationError("AiTask: Invalid model value");
+  }
   async createJob(input, queueName) {
     const jobInput = await this.getJobInput(input);
     const resolvedQueueName = queueName ?? await this.getDefaultQueueName(input);
@@ -739,6 +762,9 @@ class AiTask extends JobQueueTask {
     const modelname = input.model;
     if (!modelname)
       throw new TaskConfigurationError("AiTask: No model name found");
+    if (typeof modelname !== "string") {
+      throw new TaskConfigurationError("AiTask: Model name is not a string");
+    }
     if (this.modelCache && this.modelCache.name === modelname) {
       return this.modelCache.model;
     }
@@ -754,6 +780,9 @@ class AiTask extends JobQueueTask {
       const model = await this.getModelForInput(input);
       return model.provider;
     }
+    if (typeof input.model === "object" && input.model !== null && !Array.isArray(input.model)) {
+      return input.model.provider;
+    }
     return;
   }
   async validateInput(input) {
@@ -770,9 +799,18 @@ class AiTask extends JobQueueTask {
       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}'`);
+          if (typeof model === "string") {
+            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}'`);
+            }
+          } else if (typeof model === "object" && model !== null) {
+            const tasks = model.tasks;
+            if (Array.isArray(tasks) && tasks.length > 0 && !tasks.includes(this.type)) {
+              throw new TaskConfigurationError(`AiTask: Inline model for '${key}' is not compatible with task '${this.type}'`);
+            }
+          } else {
+            throw new TaskConfigurationError(`AiTask: Invalid model for '${key}'`);
           }
         }
       }
@@ -782,9 +820,13 @@ class AiTask extends JobQueueTask {
       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}"`);
+          if (typeof model === "string") {
+            const foundModel = await getGlobalModelRepository().findByName(model);
+            if (!foundModel) {
+              throw new TaskConfigurationError(`AiTask: Missing model for "${key}" named "${model}"`);
+            }
+          } else if (typeof model === "object" && model !== null) {} else {
+            throw new TaskConfigurationError(`AiTask: Invalid model for "${key}"`);
           }
         }
       }
@@ -804,9 +846,18 @@ class AiTask extends JobQueueTask {
       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;
+        const requestedStrings = requestedModels.filter((m) => typeof m === "string");
+        const requestedInline = requestedModels.filter((m) => typeof m === "object" && m !== null);
+        const usingStrings = requestedStrings.filter((model) => taskModels?.find((m) => m.model_id === model));
+        const usingInline = requestedInline.filter((model) => {
+          const tasks = model.tasks;
+          if (Array.isArray(tasks) && tasks.length > 0 && !tasks.includes(this.type)) {
+            return false;
+          }
+          return true;
+        });
+        const combined = [...usingInline, ...usingStrings];
+        input[key] = combined.length > 1 ? combined : combined[0];
       }
     }
     return input;
@@ -878,10 +929,10 @@ class BackgroundRemovalTask extends AiVisionTask {
   }
 }
 TaskRegistry.registerTask(BackgroundRemovalTask);
-var BackgroundRemoval = (input, config) => {
+var backgroundRemoval = (input, config) => {
   return new BackgroundRemovalTask(input, config).run();
 };
-Workflow.prototype.BackgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
+Workflow.prototype.backgroundRemoval = CreateWorkflow(BackgroundRemovalTask);
 // src/task/DocumentSplitterTask.ts
 import {
   CreateWorkflow as CreateWorkflow2,
@@ -943,10 +994,10 @@ class DocumentSplitterTask extends Task {
   }
 }
 TaskRegistry2.registerTask(DocumentSplitterTask);
-var DocumentSplitter = (input) => {
+var documentSplitter = (input) => {
   return new DocumentSplitterTask(input).run();
 };
-Workflow2.prototype.DocumentSplitter = CreateWorkflow2(DocumentSplitterTask);
+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"));
@@ -1002,10 +1053,10 @@ class DownloadModelTask extends AiTask {
   }
 }
 TaskRegistry3.registerTask(DownloadModelTask);
-var DownloadModel = (input, config) => {
+var downloadModel = (input, config) => {
   return new DownloadModelTask(input, config).run();
 };
-Workflow3.prototype.DownloadModel = CreateWorkflow3(DownloadModelTask);
+Workflow3.prototype.downloadModel = CreateWorkflow3(DownloadModelTask);
 // src/task/FaceDetectorTask.ts
 import { CreateWorkflow as CreateWorkflow4, TaskRegistry as TaskRegistry4, Workflow as Workflow4 } from "@workglow/task-graph";
 var modelSchema3 = TypeReplicateArray(TypeModel("model:FaceDetectorTask"));
@@ -1133,10 +1184,10 @@ class FaceDetectorTask extends AiVisionTask {
   }
 }
 TaskRegistry4.registerTask(FaceDetectorTask);
-var FaceDetector = (input, config) => {
+var faceDetector = (input, config) => {
   return new FaceDetectorTask(input, config).run();
 };
-Workflow4.prototype.FaceDetector = CreateWorkflow4(FaceDetectorTask);
+Workflow4.prototype.faceDetector = CreateWorkflow4(FaceDetectorTask);
 // src/task/FaceLandmarkerTask.ts
 import { CreateWorkflow as CreateWorkflow5, TaskRegistry as TaskRegistry5, Workflow as Workflow5 } from "@workglow/task-graph";
 var modelSchema4 = TypeReplicateArray(TypeModel("model:FaceLandmarkerTask"));
@@ -1295,10 +1346,10 @@ class FaceLandmarkerTask extends AiVisionTask {
   }
 }
 TaskRegistry5.registerTask(FaceLandmarkerTask);
-var FaceLandmarker = (input, config) => {
+var faceLandmarker = (input, config) => {
   return new FaceLandmarkerTask(input, config).run();
 };
-Workflow5.prototype.FaceLandmarker = CreateWorkflow5(FaceLandmarkerTask);
+Workflow5.prototype.faceLandmarker = CreateWorkflow5(FaceLandmarkerTask);
 // src/task/GestureRecognizerTask.ts
 import { CreateWorkflow as CreateWorkflow6, TaskRegistry as TaskRegistry6, Workflow as Workflow6 } from "@workglow/task-graph";
 var modelSchema5 = TypeReplicateArray(TypeModel("model:GestureRecognizerTask"));
@@ -1463,10 +1514,10 @@ class GestureRecognizerTask extends AiVisionTask {
   }
 }
 TaskRegistry6.registerTask(GestureRecognizerTask);
-var GestureRecognizer = (input, config) => {
+var gestureRecognizer = (input, config) => {
   return new GestureRecognizerTask(input, config).run();
 };
-Workflow6.prototype.GestureRecognizer = CreateWorkflow6(GestureRecognizerTask);
+Workflow6.prototype.gestureRecognizer = CreateWorkflow6(GestureRecognizerTask);
 // src/task/HandLandmarkerTask.ts
 import { CreateWorkflow as CreateWorkflow7, TaskRegistry as TaskRegistry7, Workflow as Workflow7 } from "@workglow/task-graph";
 var modelSchema6 = TypeReplicateArray(TypeModel("model:HandLandmarkerTask"));
@@ -1608,10 +1659,10 @@ class HandLandmarkerTask extends AiVisionTask {
   }
 }
 TaskRegistry7.registerTask(HandLandmarkerTask);
-var HandLandmarker = (input, config) => {
+var handLandmarker = (input, config) => {
   return new HandLandmarkerTask(input, config).run();
 };
-Workflow7.prototype.HandLandmarker = CreateWorkflow7(HandLandmarkerTask);
+Workflow7.prototype.handLandmarker = CreateWorkflow7(HandLandmarkerTask);
 // src/task/ImageClassificationTask.ts
 import { CreateWorkflow as CreateWorkflow8, TaskRegistry as TaskRegistry8, Workflow as Workflow8 } from "@workglow/task-graph";
 var modelSchema7 = TypeReplicateArray(TypeModel("model:ImageClassificationTask"));
@@ -1671,10 +1722,10 @@ class ImageClassificationTask extends AiVisionTask {
   }
 }
 TaskRegistry8.registerTask(ImageClassificationTask);
-var ImageClassification = (input, config) => {
+var imageClassification = (input, config) => {
   return new ImageClassificationTask(input, config).run();
 };
-Workflow8.prototype.ImageClassification = CreateWorkflow8(ImageClassificationTask);
+Workflow8.prototype.imageClassification = CreateWorkflow8(ImageClassificationTask);
 // src/task/ImageEmbeddingTask.ts
 import { CreateWorkflow as CreateWorkflow9, TaskRegistry as TaskRegistry9, Workflow as Workflow9 } from "@workglow/task-graph";
 var modelSchema8 = TypeReplicateArray(TypeModel("model:ImageEmbeddingTask"));
@@ -1717,10 +1768,10 @@ class ImageEmbeddingTask extends AiVisionTask {
   }
 }
 TaskRegistry9.registerTask(ImageEmbeddingTask);
-var ImageEmbedding = (input, config) => {
+var imageEmbedding = (input, config) => {
   return new ImageEmbeddingTask(input, config).run();
 };
-Workflow9.prototype.ImageEmbedding = CreateWorkflow9(ImageEmbeddingTask);
+Workflow9.prototype.imageEmbedding = CreateWorkflow9(ImageEmbeddingTask);
 // src/task/ImageSegmentationTask.ts
 import { CreateWorkflow as CreateWorkflow10, TaskRegistry as TaskRegistry10, Workflow as Workflow10 } from "@workglow/task-graph";
 var modelSchema9 = TypeReplicateArray(TypeModel("model:ImageSegmentationTask"));
@@ -1805,10 +1856,10 @@ class ImageSegmentationTask extends AiVisionTask {
   }
 }
 TaskRegistry10.registerTask(ImageSegmentationTask);
-var ImageSegmentation = (input, config) => {
+var imageSegmentation = (input, config) => {
   return new ImageSegmentationTask(input, config).run();
 };
-Workflow10.prototype.ImageSegmentation = CreateWorkflow10(ImageSegmentationTask);
+Workflow10.prototype.imageSegmentation = CreateWorkflow10(ImageSegmentationTask);
 // src/task/ImageToTextTask.ts
 import { CreateWorkflow as CreateWorkflow11, TaskRegistry as TaskRegistry11, Workflow as Workflow11 } from "@workglow/task-graph";
 var modelSchema10 = TypeReplicateArray(TypeModel("model:ImageToTextTask"));
@@ -1860,10 +1911,10 @@ class ImageToTextTask extends AiVisionTask {
   }
 }
 TaskRegistry11.registerTask(ImageToTextTask);
-var ImageToText = (input, config) => {
+var imageToText = (input, config) => {
   return new ImageToTextTask(input, config).run();
 };
-Workflow11.prototype.ImageToText = CreateWorkflow11(ImageToTextTask);
+Workflow11.prototype.imageToText = CreateWorkflow11(ImageToTextTask);
 // src/task/ObjectDetectionTask.ts
 import { CreateWorkflow as CreateWorkflow12, TaskRegistry as TaskRegistry12, Workflow as Workflow12 } from "@workglow/task-graph";
 var modelSchema11 = TypeReplicateArray(TypeModel("model:ObjectDetectionTask"));
@@ -1943,10 +1994,10 @@ class ObjectDetectionTask extends AiVisionTask {
   }
 }
 TaskRegistry12.registerTask(ObjectDetectionTask);
-var ObjectDetection = (input, config) => {
+var objectDetection = (input, config) => {
   return new ObjectDetectionTask(input, config).run();
 };
-Workflow12.prototype.ObjectDetection = CreateWorkflow12(ObjectDetectionTask);
+Workflow12.prototype.objectDetection = CreateWorkflow12(ObjectDetectionTask);
 // src/task/PoseLandmarkerTask.ts
 import { CreateWorkflow as CreateWorkflow13, TaskRegistry as TaskRegistry13, Workflow as Workflow13 } from "@workglow/task-graph";
 var modelSchema12 = TypeReplicateArray(TypeModel("model:PoseLandmarkerTask"));
@@ -2105,10 +2156,10 @@ class PoseLandmarkerTask extends AiVisionTask {
   }
 }
 TaskRegistry13.registerTask(PoseLandmarkerTask);
-var PoseLandmarker = (input, config) => {
+var poseLandmarker = (input, config) => {
   return new PoseLandmarkerTask(input, config).run();
 };
-Workflow13.prototype.PoseLandmarker = CreateWorkflow13(PoseLandmarkerTask);
+Workflow13.prototype.poseLandmarker = CreateWorkflow13(PoseLandmarkerTask);
 // src/task/TextClassificationTask.ts
 import { CreateWorkflow as CreateWorkflow14, TaskRegistry as TaskRegistry14, Workflow as Workflow14 } from "@workglow/task-graph";
 var modelSchema13 = TypeReplicateArray(TypeModel("model:TextClassificationTask"));
@@ -2186,10 +2237,10 @@ class TextClassificationTask extends AiTask {
   }
 }
 TaskRegistry14.registerTask(TextClassificationTask);
-var TextClassification = (input, config) => {
+var textClassification = (input, config) => {
   return new TextClassificationTask(input, config).run();
 };
-Workflow14.prototype.TextClassification = CreateWorkflow14(TextClassificationTask);
+Workflow14.prototype.textClassification = CreateWorkflow14(TextClassificationTask);
 // src/task/TextEmbeddingTask.ts
 import { CreateWorkflow as CreateWorkflow15, TaskRegistry as TaskRegistry15, Workflow as Workflow15 } from "@workglow/task-graph";
 var modelSchema14 = TypeReplicateArray(TypeModel("model:TextEmbeddingTask"));
@@ -2231,10 +2282,10 @@ class TextEmbeddingTask extends AiTask {
   }
 }
 TaskRegistry15.registerTask(TextEmbeddingTask);
-var TextEmbedding = async (input, config) => {
+var textEmbedding = async (input, config) => {
   return new TextEmbeddingTask(input, config).run();
 };
-Workflow15.prototype.TextEmbedding = CreateWorkflow15(TextEmbeddingTask);
+Workflow15.prototype.textEmbedding = CreateWorkflow15(TextEmbeddingTask);
 // src/task/TextFillMaskTask.ts
 import { CreateWorkflow as CreateWorkflow16, TaskRegistry as TaskRegistry16, Workflow as Workflow16 } from "@workglow/task-graph";
 var modelSchema15 = TypeReplicateArray(TypeModel("model:TextFillMaskTask"));
@@ -2299,10 +2350,10 @@ class TextFillMaskTask extends AiTask {
   }
 }
 TaskRegistry16.registerTask(TextFillMaskTask);
-var TextFillMask = (input, config) => {
+var textFillMask = (input, config) => {
   return new TextFillMaskTask(input, config).run();
 };
-Workflow16.prototype.TextFillMask = CreateWorkflow16(TextFillMaskTask);
+Workflow16.prototype.textFillMask = CreateWorkflow16(TextFillMaskTask);
 // src/task/TextGenerationTask.ts
 import { CreateWorkflow as CreateWorkflow17, TaskRegistry as TaskRegistry17, Workflow as Workflow17 } from "@workglow/task-graph";
 var generatedTextSchema2 = {
@@ -2390,10 +2441,10 @@ class TextGenerationTask extends AiTask {
   }
 }
 TaskRegistry17.registerTask(TextGenerationTask);
-var TextGeneration = (input, config) => {
+var textGeneration = (input, config) => {
   return new TextGenerationTask(input, config).run();
 };
-Workflow17.prototype.TextGeneration = CreateWorkflow17(TextGenerationTask);
+Workflow17.prototype.textGeneration = CreateWorkflow17(TextGenerationTask);
 // src/task/TextLanguageDetectionTask.ts
 import { CreateWorkflow as CreateWorkflow18, TaskRegistry as TaskRegistry18, Workflow as Workflow18 } from "@workglow/task-graph";
 var modelSchema17 = TypeReplicateArray(TypeModel("model:TextLanguageDetectionTask"));
@@ -2461,10 +2512,10 @@ class TextLanguageDetectionTask extends AiTask {
   }
 }
 TaskRegistry18.registerTask(TextLanguageDetectionTask);
-var TextLanguageDetection = (input, config) => {
+var textLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(input, config).run();
 };
-Workflow18.prototype.TextLanguageDetection = CreateWorkflow18(TextLanguageDetectionTask);
+Workflow18.prototype.textLanguageDetection = CreateWorkflow18(TextLanguageDetectionTask);
 // src/task/TextNamedEntityRecognitionTask.ts
 import { CreateWorkflow as CreateWorkflow19, TaskRegistry as TaskRegistry19, Workflow as Workflow19 } from "@workglow/task-graph";
 var modelSchema18 = TypeReplicateArray(TypeModel("model:NamedEntityRecognitionTask"));
@@ -2539,10 +2590,10 @@ class TextNamedEntityRecognitionTask extends AiTask {
   }
 }
 TaskRegistry19.registerTask(TextNamedEntityRecognitionTask);
-var TextNamedEntityRecognition = (input, config) => {
+var textNamedEntityRecognition = (input, config) => {
   return new TextNamedEntityRecognitionTask(input, config).run();
 };
-Workflow19.prototype.TextNamedEntityRecognition = CreateWorkflow19(TextNamedEntityRecognitionTask);
+Workflow19.prototype.textNamedEntityRecognition = CreateWorkflow19(TextNamedEntityRecognitionTask);
 // src/task/TextQuestionAnswerTask.ts
 import { CreateWorkflow as CreateWorkflow20, TaskRegistry as TaskRegistry20, Workflow as Workflow20 } from "@workglow/task-graph";
 var contextSchema = {
@@ -2597,10 +2648,10 @@ class TextQuestionAnswerTask extends AiTask {
   }
 }
 TaskRegistry20.registerTask(TextQuestionAnswerTask);
-var TextQuestionAnswer = (input, config) => {
+var textQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(input, config).run();
 };
-Workflow20.prototype.TextQuestionAnswer = CreateWorkflow20(TextQuestionAnswerTask);
+Workflow20.prototype.textQuestionAnswer = CreateWorkflow20(TextQuestionAnswerTask);
 // src/task/TextRewriterTask.ts
 import { CreateWorkflow as CreateWorkflow21, TaskRegistry as TaskRegistry21, Workflow as Workflow21 } from "@workglow/task-graph";
 var modelSchema20 = TypeReplicateArray(TypeModel("model:TextRewriterTask"));
@@ -2648,10 +2699,10 @@ class TextRewriterTask extends AiTask {
   }
 }
 TaskRegistry21.registerTask(TextRewriterTask);
-var TextRewriter = (input, config) => {
+var textRewriter = (input, config) => {
   return new TextRewriterTask(input, config).run();
 };
-Workflow21.prototype.TextRewriter = CreateWorkflow21(TextRewriterTask);
+Workflow21.prototype.textRewriter = CreateWorkflow21(TextRewriterTask);
 // src/task/TextSummaryTask.ts
 import { CreateWorkflow as CreateWorkflow22, TaskRegistry as TaskRegistry22, Workflow as Workflow22 } from "@workglow/task-graph";
 var modelSchema21 = TypeReplicateArray(TypeModel("model:TextSummaryTask"));
@@ -2694,10 +2745,10 @@ class TextSummaryTask extends AiTask {
   }
 }
 TaskRegistry22.registerTask(TextSummaryTask);
-var TextSummary = async (input, config) => {
+var textSummary = async (input, config) => {
   return new TextSummaryTask(input, config).run();
 };
-Workflow22.prototype.TextSummary = CreateWorkflow22(TextSummaryTask);
+Workflow22.prototype.textSummary = CreateWorkflow22(TextSummaryTask);
 // src/task/TextTranslationTask.ts
 import { CreateWorkflow as CreateWorkflow23, TaskRegistry as TaskRegistry23, Workflow as Workflow23 } from "@workglow/task-graph";
 var modelSchema22 = TypeReplicateArray(TypeModel("model:TextTranslationTask"));
@@ -2763,10 +2814,10 @@ class TextTranslationTask extends AiTask {
   }
 }
 TaskRegistry23.registerTask(TextTranslationTask);
-var TextTranslation = (input, config) => {
+var textTranslation = (input, config) => {
   return new TextTranslationTask(input, config).run();
 };
-Workflow23.prototype.TextTranslation = CreateWorkflow23(TextTranslationTask);
+Workflow23.prototype.textTranslation = CreateWorkflow23(TextTranslationTask);
 // src/task/UnloadModelTask.ts
 import { CreateWorkflow as CreateWorkflow24, TaskRegistry as TaskRegistry24, Workflow as Workflow24 } from "@workglow/task-graph";
 var modelSchema23 = TypeReplicateArray(TypeModel("model"));
@@ -2801,10 +2852,10 @@ class UnloadModelTask extends AiTask {
   static cacheable = false;
 }
 TaskRegistry24.registerTask(UnloadModelTask);
-var UnloadModel = (input, config) => {
+var unloadModel = (input, config) => {
   return new UnloadModelTask(input, config).run();
 };
-Workflow24.prototype.UnloadModel = CreateWorkflow24(UnloadModelTask);
+Workflow24.prototype.unloadModel = CreateWorkflow24(UnloadModelTask);
 // src/task/VectorSimilarityTask.ts
 import {
   ArrayTask,
@@ -2906,10 +2957,10 @@ class VectorSimilarityTask extends ArrayTask {
   }
 }
 TaskRegistry25.registerTask(VectorSimilarityTask);
-var Similarity = (input, config) => {
+var similarity = (input, config) => {
   return new VectorSimilarityTask(input, config).run();
 };
-Workflow25.prototype.Similarity = CreateWorkflow25(VectorSimilarityTask);
+Workflow25.prototype.similarity = CreateWorkflow25(VectorSimilarityTask);
 function inner(arr1, arr2) {
   return 1 - arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
 }
@@ -2937,16 +2988,40 @@ function normalize(vector) {
   return new Float32Array(normalized);
 }
 export {
+  unloadModel,
+  textTranslation,
+  textSummary,
+  textRewriter,
+  textQuestionAnswer,
+  textNamedEntityRecognition,
+  textLanguageDetection,
+  textGeneration,
+  textFillMask,
+  textEmbedding,
+  textClassification,
+  similarity,
   setGlobalModelRepository,
   setAiProviderRegistry,
+  poseLandmarker,
+  objectDetection,
   normalize,
   magnitude,
   inner,
+  imageToText,
+  imageSegmentation,
+  imageEmbedding,
+  imageClassification,
+  handLandmarker,
   getGlobalModelRepository,
   getAiProviderRegistry,
+  gestureRecognizer,
+  faceLandmarker,
+  faceDetector,
+  downloadModel,
+  documentSplitter,
+  backgroundRemoval,
   VectorSimilarityTask,
   UnloadModelTask,
-  UnloadModel,
   TypedArraySchema,
   TypeReplicateArray,
   TypeModelByDetail,
@@ -2960,97 +3035,75 @@ export {
   TextTranslationTask,
   TextTranslationOutputSchema,
   TextTranslationInputSchema,
-  TextTranslation,
   TextSummaryTask,
   TextSummaryOutputSchema,
   TextSummaryInputSchema,
-  TextSummary,
   TextRewriterTask,
   TextRewriterOutputSchema,
   TextRewriterInputSchema,
-  TextRewriter,
   TextQuestionAnswerTask,
   TextQuestionAnswerOutputSchema,
   TextQuestionAnswerInputSchema,
-  TextQuestionAnswer,
   TextNamedEntityRecognitionTask,
   TextNamedEntityRecognitionOutputSchema,
   TextNamedEntityRecognitionInputSchema,
-  TextNamedEntityRecognition,
   TextLanguageDetectionTask,
   TextLanguageDetectionOutputSchema,
   TextLanguageDetectionInputSchema,
-  TextLanguageDetection,
   TextGenerationTask,
   TextGenerationOutputSchema,
   TextGenerationInputSchema,
-  TextGeneration,
   TextFragment,
   TextFillMaskTask,
   TextFillMaskOutputSchema,
   TextFillMaskInputSchema,
-  TextFillMask,
   TextEmbeddingTask,
   TextEmbeddingOutputSchema,
   TextEmbeddingInputSchema,
-  TextEmbedding,
   TextClassificationTask,
   TextClassificationOutputSchema,
   TextClassificationInputSchema,
-  TextClassification,
   TableFragment,
   SimilarityFn,
-  Similarity,
   PoseLandmarkerTask,
   PoseLandmarkerOutputSchema,
   PoseLandmarkerInputSchema,
-  PoseLandmarker,
   ObjectDetectionTask,
   ObjectDetectionOutputSchema,
   ObjectDetectionInputSchema,
-  ObjectDetection,
-  ModelSchema,
   ModelRepository,
+  ModelRecordSchema,
   ModelPrimaryKeyNames,
+  ModelConfigSchema,
   MODEL_REPOSITORY,
   InMemoryModelRepository,
   ImageToTextTask,
   ImageToTextOutputSchema,
   ImageToTextInputSchema,
-  ImageToText,
   ImageSegmentationTask,
   ImageSegmentationOutputSchema,
   ImageSegmentationInputSchema,
-  ImageSegmentation,
   ImageFragment,
   ImageEmbeddingTask,
   ImageEmbeddingOutputSchema,
   ImageEmbeddingInputSchema,
-  ImageEmbedding,
   ImageClassificationTask,
   ImageClassificationOutputSchema,
   ImageClassificationInputSchema,
-  ImageClassification,
   HandLandmarkerTask,
   HandLandmarkerOutputSchema,
   HandLandmarkerInputSchema,
-  HandLandmarker,
   GestureRecognizerTask,
   GestureRecognizerOutputSchema,
   GestureRecognizerInputSchema,
-  GestureRecognizer,
   FaceLandmarkerTask,
   FaceLandmarkerOutputSchema,
   FaceLandmarkerInputSchema,
-  FaceLandmarker,
   FaceDetectorTask,
   FaceDetectorOutputSchema,
   FaceDetectorInputSchema,
-  FaceDetector,
   DownloadModelTask,
-  DownloadModel,
   DocumentSplitterTask,
-  DocumentSplitter,
   DocumentSection,
   DocumentConverterText,
   DocumentConverterMarkdown,
@@ -3059,10 +3112,9 @@ export {
   BackgroundRemovalTask,
   BackgroundRemovalOutputSchema,
   BackgroundRemovalInputSchema,
-  BackgroundRemoval,
   AiTask,
   AiProviderRegistry,
   AiJob
 };
 
-//# debugId=52C81000C6953A8164756E2164756E21
+//# debugId=BDD8E58EC0826A3764756E2164756E21