@workglow/ai 0.2.19 → 0.2.21

package/dist/bun.js

@@ -47,6 +47,9 @@ class AiProviderRegistry {
   registerStrategyResolver(providerName, resolver) {
     this.strategyResolvers.set(providerName, resolver);
   }
+  setDefaultStrategy(strategy) {
+    this.defaultStrategy = strategy;
+  }
   getStrategy(model) {
     const resolver = this.strategyResolvers.get(model.provider);
     if (resolver)
@@ -149,6 +152,41 @@ function setAiProviderRegistry(pr) {
   providerRegistry = pr;
 }
 
+// src/errors/ImageGenerationErrors.ts
+class ProviderUnsupportedFeatureError extends Error {
+  field;
+  modelId;
+  retryable = false;
+  constructor(field, modelId, detail) {
+    super(`Model "${modelId}" does not support input field "${field}": ${detail}`);
+    this.field = field;
+    this.modelId = modelId;
+    this.name = "ProviderUnsupportedFeatureError";
+  }
+}
+
+class ImageGenerationContentPolicyError extends Error {
+  modelId;
+  providerReason;
+  retryable = false;
+  constructor(modelId, providerReason) {
+    super(`Image generation refused by ${modelId}: ${providerReason}`);
+    this.modelId = modelId;
+    this.providerReason = providerReason;
+    this.name = "ImageGenerationContentPolicyError";
+  }
+}
+
+class ImageGenerationProviderError extends Error {
+  modelId;
+  retryable = true;
+  constructor(modelId, message, options) {
+    super(`${modelId}: ${message}`, options);
+    this.modelId = modelId;
+    this.name = "ImageGenerationProviderError";
+  }
+}
+
 // src/job/AiJob.ts
 var DEFAULT_AI_TIMEOUT_MS = 120000;
 var LOCAL_INFERENCE_DEFAULT_TIMEOUT_MS = 300000;
@@ -165,6 +203,12 @@ function classifyProviderError(err, taskType, provider) {
   if (err instanceof PermanentJobError || err instanceof RetryableJobError || err instanceof AbortSignalJobError) {
     return err;
   }
+  if (err instanceof ProviderUnsupportedFeatureError || err instanceof ImageGenerationContentPolicyError) {
+    return new PermanentJobError(err.message);
+  }
+  if (err instanceof ImageGenerationProviderError) {
+    return err.retryable ? new RetryableJobError(err.message) : new PermanentJobError(err.message);
+  }
   const message = err instanceof Error ? err.message : String(err);
   const status = typeof err?.status === "number" ? err.status : typeof err?.statusCode === "number" ? err.statusCode : (() => {
     const m = message.match(/\b([45]\d{2})\b/);
@@ -251,23 +295,14 @@ class AiJob extends Job {
       return;
     }
     const model = input.taskInput.model;
-    let lastFinishData;
     const timeoutMs = resolveAiJobTimeoutMs(input.aiProvider, input.timeoutMs);
     const timeoutSignal = AbortSignal.timeout(timeoutMs);
     const combinedSignal = AbortSignal.any([context.signal, timeoutSignal]);
     try {
-      for await (const event of streamFn(input.taskInput, model, combinedSignal, input.outputSchema, input.sessionId)) {
-        if (event.type === "finish") {
-          lastFinishData = event.data;
-        }
-        yield event;
-      }
+      yield* streamFn(input.taskInput, model, combinedSignal, input.outputSchema, input.sessionId);
     } catch (err) {
       const logger = getLogger();
       logger.warn(`AiJob: Stream error for ${input.taskType} (${input.aiProvider}): ${err instanceof Error ? err.message : String(err)}`);
-      if (lastFinishData === undefined) {
-        yield { type: "finish", data: {} };
-      }
       throw classifyProviderError(err, input.taskType, input.aiProvider);
     }
   }
@@ -884,11 +919,50 @@ function TypeSingleOrArray(type) {
     anyOf: [type, { type: "array", items: type }]
   };
 }
+var TypeLandmark = {
+  type: "object",
+  properties: {
+    x: {
+      type: "number",
+      title: "X Coordinate",
+      description: "X coordinate normalized to [0.0, 1.0]"
+    },
+    y: {
+      type: "number",
+      title: "Y Coordinate",
+      description: "Y coordinate normalized to [0.0, 1.0]"
+    },
+    z: {
+      type: "number",
+      title: "Z Coordinate",
+      description: "Z coordinate (depth)"
+    }
+  },
+  required: ["x", "y", "z"],
+  format: "point:3d:relative",
+  additionalProperties: false
+};
+var TypePoseLandmark = {
+  ...TypeLandmark,
+  properties: {
+    ...TypeLandmark.properties,
+    visibility: {
+      type: "number",
+      title: "Visibility",
+      description: "Likelihood of the landmark being visible within the image"
+    },
+    presence: {
+      type: "number",
+      title: "Presence",
+      description: "Likelihood of the landmark being present in the image"
+    }
+  }
+};
 var TypeImageInput = {
   type: "object",
   properties: {},
   title: "Image",
-  description: "Image as data URI, Blob, ImageBitmap, ImageBinary, or GpuImage \u2014 hydrated to GpuImage by the runner",
+  description: "Image as data: URI, Blob, ImageBitmap, or ImageValue \u2014 hydrated to ImageValue at task entry",
   format: "image"
 };
 var TypeAudioInput = {
@@ -1118,6 +1192,8 @@ class AiTask extends Task {
 // src/task/base/StreamingAiTask.ts
 class StreamingAiTask extends AiTask {
   static type = "StreamingAiTask";
+  static preparingPhaseLabel = "Preparing";
+  static streamingPhaseLabel = "Streaming";
   async* executeStream(input, context) {
     const model = input.model;
     if (!model || typeof model !== "object") {
@@ -1137,7 +1213,16 @@ class StreamingAiTask extends AiTask {
           defaultPort = firstProp;
       }
     }
+    const ctor = this.constructor;
+    const preparingLabel = ctor.preparingPhaseLabel;
+    const streamingLabel = ctor.streamingPhaseLabel;
+    yield { type: "phase", message: preparingLabel, progress: undefined };
+    let firstDataSeen = false;
     for await (const event of strategy.executeStream(jobInput, context, this.runConfig.runnerId)) {
+      if (!firstDataSeen && (event.type === "text-delta" || event.type === "object-delta" || event.type === "snapshot")) {
+        firstDataSeen = true;
+        yield { type: "phase", message: streamingLabel, progress: undefined };
+      }
       if (event.type === "text-delta") {
         yield { ...event, port: event.port ?? defaultPort };
       } else if (event.type === "object-delta") {
@@ -1362,6 +1447,7 @@ var AiChatOutputSchema = {
 
 class AiChatTask extends StreamingAiTask {
   static type = "AiChatTask";
+  static streamingPhaseLabel = "Replying";
   static category = "AI Chat";
   static title = "AI Chat";
   static description = "Multi-turn chat with a language model, using a human connector to collect user input between turns.";
@@ -1507,40 +1593,15 @@ class AiChatTask extends StreamingAiTask {
 
 // src/task/BackgroundRemovalTask.ts
 import { CreateWorkflow, Workflow } from "@workglow/task-graph";
+import { ImageValueSchema } from "@workglow/util/media";
 
 // src/task/base/AiVisionTask.ts
 class AiVisionTask extends AiTask {
   static type = "AiVisionTask";
-  async getJobInput(input) {
-    const jobInput = await super.getJobInput(input);
-    if (!input.image)
-      return jobInput;
-    const provider = input.model.provider;
-    const wantsBitmap = typeof provider === "string" && provider.startsWith("TENSORFLOW_MEDIAPIPE") && typeof ImageBitmap !== "undefined";
-    const materializeOne = async (img) => {
-      if (wantsBitmap) {
-        const bin = await img.materialize();
-        const id = new ImageData(bin.data, bin.width, bin.height);
-        return createImageBitmap(id);
-      }
-      return img.materialize();
-    };
-    const value = input.image;
-    const materialized = Array.isArray(value) ? await Promise.all(value.map(materializeOne)) : await materializeOne(value);
-    jobInput.taskInput.image = materialized;
-    return jobInput;
-  }
 }
 
 // src/task/BackgroundRemovalTask.ts
 var modelSchema2 = 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: {
@@ -1553,7 +1614,10 @@ var BackgroundRemovalInputSchema = {
 var BackgroundRemovalOutputSchema = {
   type: "object",
   properties: {
-    image: processedImageSchema
+    image: ImageValueSchema({
+      title: "Image",
+      description: "Image with transparent background"
+    })
   },
   required: ["image"],
   additionalProperties: false
@@ -1561,7 +1625,7 @@ var BackgroundRemovalOutputSchema = {
 
 class BackgroundRemovalTask extends AiVisionTask {
   static type = "BackgroundRemovalTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Background Removal";
   static description = "Removes backgrounds from images, producing images with transparent backgrounds";
   static inputSchema() {
@@ -1617,7 +1681,7 @@ var TextEmbeddingOutputSchema = {
 
 class TextEmbeddingTask extends AiTask {
   static type = "TextEmbeddingTask";
-  static category = "AI Text Model";
+  static category = "AI Text";
   static title = "Text Embedding";
   static description = "Generates vector embeddings for text to capture semantic meaning";
   static inputSchema() {
@@ -2000,7 +2064,7 @@ var CountTokensOutputSchema = {
 
 class CountTokensTask extends AiTask {
   static type = "CountTokensTask";
-  static category = "AI Text Model";
+  static category = "AI Text";
   static title = "Count Tokens";
   static description = "Counts the number of tokens in a text string using the model's tokenizer";
   static cacheable = true;
@@ -2386,7 +2450,7 @@ var TextNamedEntityRecognitionOutputSchema = {
 
 class TextNamedEntityRecognitionTask extends AiTask {
   static type = "TextNamedEntityRecognitionTask";
-  static category = "AI Text Model";
+  static category = "AI Text";
   static title = "Named Entity Recognition";
   static description = "Extracts named entities from text";
   static inputSchema() {
@@ -2433,8 +2497,9 @@ var TextSummaryOutputSchema = {
 
 class TextSummaryTask extends StreamingAiTask {
   static type = "TextSummaryTask";
-  static category = "AI Text Model";
+  static category = "AI Text";
   static title = "Text Summary";
+  static streamingPhaseLabel = "Summarizing";
   static description = "Summarizes text into a shorter form while preserving key information";
   static inputSchema() {
     return TextSummaryInputSchema;
@@ -2834,9 +2899,196 @@ var downloadModel = (input, config) => {
 };
 Workflow11.prototype.downloadModel = CreateWorkflow11(DownloadModelTask);
 
-// src/task/FaceDetectorTask.ts
+// src/task/generation/ImageEditTask.ts
 import { CreateWorkflow as CreateWorkflow12, Workflow as Workflow12 } from "@workglow/task-graph";
-var modelSchema9 = TypeModel("model:FaceDetectorTask");
+import { ImageValueSchema as ImageValueSchema3 } from "@workglow/util/media";
+
+// src/task/base/AiImageOutputTask.ts
+class AiImageOutputTask extends StreamingAiTask {
+  static type = "AiImageOutputTask";
+  static streamingPhaseLabel = "Rendering";
+  _latestPartial = undefined;
+  get cacheable() {
+    const seed = this.runInputData?.seed;
+    if (seed === undefined || seed === null)
+      return false;
+    return super.cacheable;
+  }
+  ingestPartial(image) {
+    this._latestPartial = image;
+  }
+  takeFinalPartial() {
+    const partial = this._latestPartial;
+    this._latestPartial = undefined;
+    return partial;
+  }
+  discardPartial() {
+    this._latestPartial = undefined;
+  }
+  async* executeStream(input, context) {
+    try {
+      for await (const event of super.executeStream(input, context)) {
+        if (event.type === "snapshot") {
+          const newImage = event.data?.image;
+          if (newImage) {
+            this.ingestPartial(newImage);
+          }
+          yield event;
+        } else if (event.type === "finish") {
+          this._latestPartial = undefined;
+          yield event;
+        } else {
+          yield event;
+        }
+      }
+    } catch (err) {
+      this.discardPartial();
+      throw err;
+    }
+  }
+  async executePreview(_input, _context) {
+    if (this._latestPartial !== undefined) {
+      return { image: this._latestPartial };
+    }
+    const prior = this.runOutputData?.image;
+    if (prior !== undefined) {
+      return { image: prior };
+    }
+    return;
+  }
+  async cleanup() {
+    this.discardPartial();
+  }
+  async validateProviderImageInput(input) {
+    const model = input.model;
+    if (!model || typeof model === "string")
+      return;
+    const provider = model.provider;
+    const validator = AiImageOutputTask._providerValidators.get(provider);
+    if (validator) {
+      await validator(this.type, input, model);
+    }
+  }
+  static _providerValidators = new Map;
+  static registerProviderImageValidator(providerName, validator) {
+    AiImageOutputTask._providerValidators.set(providerName, validator);
+  }
+  static unregisterProviderImageValidator(providerName) {
+    AiImageOutputTask._providerValidators.delete(providerName);
+  }
+  static UnsupportedFeatureError = ProviderUnsupportedFeatureError;
+}
+
+// src/task/generation/AiImageSchemas.ts
+import { ImageValueSchema as ImageValueSchema2 } from "@workglow/util/media";
+var AspectRatioSchema = {
+  type: "string",
+  title: "Aspect Ratio",
+  description: "Output image aspect ratio. Mapped per-provider to the nearest supported size.",
+  enum: ["1:1", "16:9", "9:16", "4:3", "3:4"],
+  default: "1:1"
+};
+var QualitySchema = {
+  type: "string",
+  title: "Quality",
+  description: "Generation quality. Only honored by providers that support it (gpt-image-2).",
+  enum: ["low", "medium", "high"],
+  "x-ui-group": "Configuration"
+};
+var AiImageOptionsProperties = {
+  aspectRatio: AspectRatioSchema,
+  quality: QualitySchema,
+  seed: {
+    type: "number",
+    title: "Seed",
+    description: "Random seed for reproducibility. When unset, results are non-deterministic and the task is treated as not cacheable.",
+    "x-ui-group": "Configuration"
+  },
+  negativePrompt: {
+    type: "string",
+    title: "Negative Prompt",
+    description: "What the model should avoid. Honored by providers that support it (Imagen, HF diffusion models).",
+    "x-ui-group": "Configuration"
+  },
+  providerOptions: {
+    type: "object",
+    title: "Provider Options",
+    description: "Provider-specific options that don't normalize across providers (e.g., DALL-E style, HF guidance scale).",
+    additionalProperties: true,
+    "x-ui-group": "Advanced"
+  }
+};
+var AiImageOutputSchema = {
+  type: "object",
+  properties: {
+    image: ImageValueSchema2({
+      title: "Image",
+      description: "Generated image",
+      "x-stream": "replace"
+    })
+  },
+  required: ["image"],
+  additionalProperties: false
+};
+
+// src/task/generation/ImageEditTask.ts
+var modelSchema9 = TypeModel("model:ImageEditTask");
+var ImageEditInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema9,
+    prompt: {
+      type: "string",
+      title: "Prompt",
+      description: "Text describing the edit to apply"
+    },
+    image: ImageValueSchema3({
+      title: "Image",
+      description: "Primary image to edit"
+    }),
+    mask: ImageValueSchema3({
+      title: "Mask",
+      description: "Optional inpainting mask. Transparent regions indicate where to edit. Supported by OpenAI and HF inpainting models."
+    }),
+    additionalImages: {
+      type: "array",
+      title: "Additional Images",
+      description: "Optional reference / composite images. Used by gpt-image-2 and Gemini 2.5 Flash Image for multi-image edits.",
+      items: ImageValueSchema3()
+    },
+    ...AiImageOptionsProperties
+  },
+  required: ["model", "prompt", "image"],
+  additionalProperties: false
+};
+var ImageEditOutputSchema = AiImageOutputSchema;
+
+class ImageEditTask extends AiImageOutputTask {
+  static type = "ImageEditTask";
+  static category = "AI Vision";
+  static title = "Edit Image";
+  static description = "Edits an input image guided by a prompt. Optionally accepts a mask (inpaint) and/or additional reference images (composite).";
+  static cacheable = true;
+  static inputSchema() {
+    return ImageEditInputSchema;
+  }
+  static outputSchema() {
+    return ImageEditOutputSchema;
+  }
+  async validateInput(input) {
+    const ok = await super.validateInput(input);
+    if (!ok)
+      return false;
+    await this.validateProviderImageInput(input);
+    return true;
+  }
+}
+var imageEdit = (input, config) => new ImageEditTask(config).run(input);
+Workflow12.prototype.imageEdit = CreateWorkflow12(ImageEditTask);
+
+// src/task/FaceDetectorTask.ts
+import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
+var modelSchema10 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
   properties: {
@@ -2909,7 +3161,7 @@ var FaceDetectorInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema9,
+    model: modelSchema10,
     minDetectionConfidence: {
       type: "number",
       minimum: 0,
@@ -2950,7 +3202,7 @@ var FaceDetectorOutputSchema = {
 
 class FaceDetectorTask extends AiVisionTask {
   static type = "FaceDetectorTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Face Detector";
   static description = "Detects faces in images. Locates faces and identifies facial keypoints like eyes, nose, and mouth.";
   static inputSchema() {
@@ -2963,33 +3215,11 @@ class FaceDetectorTask extends AiVisionTask {
 var faceDetector = (input, config) => {
   return new FaceDetectorTask(config).run(input);
 };
-Workflow12.prototype.faceDetector = CreateWorkflow12(FaceDetectorTask);
+Workflow13.prototype.faceDetector = CreateWorkflow13(FaceDetectorTask);
 
 // src/task/FaceLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
-var modelSchema10 = TypeModel("model:FaceLandmarkerTask");
-var TypeLandmark = {
-  type: "object",
-  properties: {
-    x: {
-      type: "number",
-      title: "X Coordinate",
-      description: "X coordinate normalized to [0.0, 1.0]"
-    },
-    y: {
-      type: "number",
-      title: "Y Coordinate",
-      description: "Y coordinate normalized to [0.0, 1.0]"
-    },
-    z: {
-      type: "number",
-      title: "Z Coordinate",
-      description: "Z coordinate (depth)"
-    }
-  },
-  required: ["x", "y", "z"],
-  additionalProperties: false
-};
+import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
+var modelSchema11 = TypeModel("model:FaceLandmarkerTask");
 var TypeBlendshape = {
   type: "object",
   properties: {
@@ -3022,7 +3252,8 @@ var TypeFaceLandmarkerDetection = {
       type: "array",
       items: TypeLandmark,
       title: "Landmarks",
-      description: "478 facial landmarks in image coordinates"
+      description: "478 facial landmarks in image coordinates",
+      format: "points:3d:relative"
     },
     blendshapes: {
       type: "array",
@@ -3039,7 +3270,7 @@ var FaceLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema10,
+    model: modelSchema11,
     numFaces: {
       type: "number",
       minimum: 1,
@@ -3112,7 +3343,7 @@ var FaceLandmarkerOutputSchema = {
 
 class FaceLandmarkerTask extends AiVisionTask {
   static type = "FaceLandmarkerTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Face Landmarker";
   static description = "Detects facial landmarks and expressions in images. Identifies 478 facial landmarks, blendshapes for expressions, and transformation matrices for AR effects.";
   static inputSchema() {
@@ -3125,33 +3356,53 @@ class FaceLandmarkerTask extends AiVisionTask {
 var faceLandmarker = (input, config) => {
   return new FaceLandmarkerTask(config).run(input);
 };
-Workflow13.prototype.faceLandmarker = CreateWorkflow13(FaceLandmarkerTask);
+Workflow14.prototype.faceLandmarker = CreateWorkflow14(FaceLandmarkerTask);
 
-// src/task/GestureRecognizerTask.ts
-import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
-var modelSchema11 = TypeModel("model:GestureRecognizerTask");
-var TypeLandmark2 = {
+// src/task/generation/ImageGenerateTask.ts
+import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
+var modelSchema12 = TypeModel("model:ImageGenerateTask");
+var ImageGenerateInputSchema = {
   type: "object",
   properties: {
-    x: {
-      type: "number",
-      title: "X Coordinate",
-      description: "X coordinate normalized to [0.0, 1.0]"
-    },
-    y: {
-      type: "number",
-      title: "Y Coordinate",
-      description: "Y coordinate normalized to [0.0, 1.0]"
+    model: modelSchema12,
+    prompt: {
+      type: "string",
+      title: "Prompt",
+      description: "Text describing the image to generate"
     },
-    z: {
-      type: "number",
-      title: "Z Coordinate",
-      description: "Z coordinate (depth)"
-    }
+    ...AiImageOptionsProperties
   },
-  required: ["x", "y", "z"],
+  required: ["model", "prompt"],
   additionalProperties: false
 };
+var ImageGenerateOutputSchema = AiImageOutputSchema;
+
+class ImageGenerateTask extends AiImageOutputTask {
+  static type = "ImageGenerateTask";
+  static category = "AI Vision";
+  static title = "Generate Image";
+  static description = "Generates an image from a text prompt using configurable AI image-generation models.";
+  static cacheable = true;
+  static inputSchema() {
+    return ImageGenerateInputSchema;
+  }
+  static outputSchema() {
+    return ImageGenerateOutputSchema;
+  }
+  async validateInput(input) {
+    const ok = await super.validateInput(input);
+    if (!ok)
+      return false;
+    await this.validateProviderImageInput(input);
+    return true;
+  }
+}
+var imageGenerate = (input, config) => new ImageGenerateTask(config).run(input);
+Workflow15.prototype.imageGenerate = CreateWorkflow15(ImageGenerateTask);
+
+// src/task/GestureRecognizerTask.ts
+import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
+var modelSchema13 = TypeModel("model:GestureRecognizerTask");
 var TypeGesture = {
   type: "object",
   properties: {
@@ -3203,15 +3454,17 @@ var TypeHandGestureDetection = {
     },
     landmarks: {
       type: "array",
-      items: TypeLandmark2,
+      items: TypeLandmark,
       title: "Landmarks",
-      description: "21 hand landmarks in image coordinates"
+      description: "21 hand landmarks in image coordinates",
+      format: "points:3d:relative"
     },
     worldLandmarks: {
       type: "array",
-      items: TypeLandmark2,
+      items: TypeLandmark,
       title: "World Landmarks",
-      description: "21 hand landmarks in 3D world coordinates (meters)"
+      description: "21 hand landmarks in 3D world coordinates (meters)",
+      format: "points:3d:meters"
     }
   },
   required: ["gestures", "handedness", "landmarks", "worldLandmarks"],
@@ -3221,7 +3474,7 @@ var GestureRecognizerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema11,
+    model: modelSchema13,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3280,7 +3533,7 @@ var GestureRecognizerOutputSchema = {
 
 class GestureRecognizerTask extends AiVisionTask {
   static type = "GestureRecognizerTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Gesture Recognizer";
   static description = "Recognizes hand gestures in images. Detects hand landmarks, identifies gestures (thumbs up, victory, etc.), and classifies handedness.";
   static inputSchema() {
@@ -3293,33 +3546,11 @@ class GestureRecognizerTask extends AiVisionTask {
 var gestureRecognizer = (input, config) => {
   return new GestureRecognizerTask(config).run(input);
 };
-Workflow14.prototype.gestureRecognizer = CreateWorkflow14(GestureRecognizerTask);
+Workflow16.prototype.gestureRecognizer = CreateWorkflow16(GestureRecognizerTask);
 
 // src/task/HandLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
-var modelSchema12 = TypeModel("model:HandLandmarkerTask");
-var TypeLandmark3 = {
-  type: "object",
-  properties: {
-    x: {
-      type: "number",
-      title: "X Coordinate",
-      description: "X coordinate normalized to [0.0, 1.0]"
-    },
-    y: {
-      type: "number",
-      title: "Y Coordinate",
-      description: "Y coordinate normalized to [0.0, 1.0]"
-    },
-    z: {
-      type: "number",
-      title: "Z Coordinate",
-      description: "Z coordinate (depth)"
-    }
-  },
-  required: ["x", "y", "z"],
-  additionalProperties: false
-};
+import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
+var modelSchema14 = TypeModel("model:HandLandmarkerTask");
 var TypeHandedness2 = {
   type: "object",
   properties: {
@@ -3348,15 +3579,17 @@ var TypeHandDetection = {
     },
     landmarks: {
       type: "array",
-      items: TypeLandmark3,
+      items: TypeLandmark,
       title: "Landmarks",
-      description: "21 hand landmarks in image coordinates"
+      description: "21 hand landmarks in image coordinates",
+      format: "points:3d:relative"
     },
     worldLandmarks: {
       type: "array",
-      items: TypeLandmark3,
+      items: TypeLandmark,
       title: "World Landmarks",
-      description: "21 hand landmarks in 3D world coordinates (meters)"
+      description: "21 hand landmarks in 3D world coordinates (meters)",
+      format: "points:3d:meters"
     }
   },
   required: ["handedness", "landmarks", "worldLandmarks"],
@@ -3366,7 +3599,7 @@ var HandLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema12,
+    model: modelSchema14,
     numHands: {
       type: "number",
       minimum: 1,
@@ -3425,7 +3658,7 @@ var HandLandmarkerOutputSchema = {
 
 class HandLandmarkerTask extends AiVisionTask {
   static type = "HandLandmarkerTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Hand Landmarker";
   static description = "Detects hand landmarks in images. Identifies 21 hand landmarks and classifies left vs. right hands.";
   static inputSchema() {
@@ -3438,7 +3671,7 @@ class HandLandmarkerTask extends AiVisionTask {
 var handLandmarker = (input, config) => {
   return new HandLandmarkerTask(config).run(input);
 };
-Workflow15.prototype.handLandmarker = CreateWorkflow15(HandLandmarkerTask);
+Workflow17.prototype.handLandmarker = CreateWorkflow17(HandLandmarkerTask);
 
 // src/task/HierarchicalChunkerTask.ts
 import {
@@ -3447,9 +3680,9 @@ import {
   getChildren as getChildren2,
   hasChildren as hasChildren2
 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow16, Task as Task7, Workflow as Workflow16 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow18, Task as Task7, Workflow as Workflow18 } from "@workglow/task-graph";
 import { uuid4 } from "@workglow/util";
-var modelSchema13 = TypeModel("model", {
+var modelSchema15 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
@@ -3495,7 +3728,7 @@ var inputSchema6 = {
       description: "Strategy for chunking",
       default: "hierarchical"
     },
-    model: modelSchema13
+    model: modelSchema15
   },
   required: ["doc_id", "documentTree"],
   additionalProperties: false
@@ -3674,11 +3907,11 @@ class HierarchicalChunkerTask extends Task7 {
 var hierarchicalChunker = (input, config) => {
   return new HierarchicalChunkerTask(config).run(input);
 };
-Workflow16.prototype.hierarchicalChunker = CreateWorkflow16(HierarchicalChunkerTask);
+Workflow18.prototype.hierarchicalChunker = CreateWorkflow18(HierarchicalChunkerTask);
 
 // src/task/HierarchyJoinTask.ts
 import { ChunkRecordArraySchema as ChunkRecordArraySchema2, TypeKnowledgeBase as TypeKnowledgeBase4 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow17, Task as Task8, Workflow as Workflow17 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow19, Task as Task8, Workflow as Workflow19 } from "@workglow/task-graph";
 var inputSchema7 = {
   type: "object",
   properties: {
@@ -3849,11 +4082,11 @@ class HierarchyJoinTask extends Task8 {
 var hierarchyJoin = (input, config) => {
   return new HierarchyJoinTask(config).run(input);
 };
-Workflow17.prototype.hierarchyJoin = CreateWorkflow17(HierarchyJoinTask);
+Workflow19.prototype.hierarchyJoin = CreateWorkflow19(HierarchyJoinTask);
 
 // src/task/KbToDocumentsTask.ts
 import { TypeKnowledgeBase as TypeKnowledgeBase5 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow18, Task as Task9, Workflow as Workflow18 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow20, Task as Task9, Workflow as Workflow20 } from "@workglow/task-graph";
 var inputSchema8 = {
   type: "object",
   properties: {
@@ -3938,16 +4171,16 @@ class KbToDocumentsTask extends Task9 {
 var kbToDocuments = (input, config) => {
   return new KbToDocumentsTask(config).run(input);
 };
-Workflow18.prototype.kbToDocuments = CreateWorkflow18(KbToDocumentsTask);
+Workflow20.prototype.kbToDocuments = CreateWorkflow20(KbToDocumentsTask);
 
 // src/task/ImageClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow19, Workflow as Workflow19 } from "@workglow/task-graph";
-var modelSchema14 = TypeModel("model:ImageClassificationTask");
+import { CreateWorkflow as CreateWorkflow21, Workflow as Workflow21 } from "@workglow/task-graph";
+var modelSchema16 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema14,
+    model: modelSchema16,
     categories: {
       type: "array",
       items: {
@@ -3988,7 +4221,7 @@ var ImageClassificationOutputSchema = {
 
 class ImageClassificationTask extends AiVisionTask {
   static type = "ImageClassificationTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Image Classification";
   static description = "Classifies images into categories using vision models. Supports zero-shot classification when categories are provided.";
   static inputSchema() {
@@ -4001,19 +4234,19 @@ class ImageClassificationTask extends AiVisionTask {
 var imageClassification = (input, config) => {
   return new ImageClassificationTask(config).run(input);
 };
-Workflow19.prototype.imageClassification = CreateWorkflow19(ImageClassificationTask);
+Workflow21.prototype.imageClassification = CreateWorkflow21(ImageClassificationTask);
 
 // src/task/ImageEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow20, Workflow as Workflow20 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
 import {
   TypedArraySchema as TypedArraySchema4
 } from "@workglow/util/schema";
-var modelSchema15 = TypeModel("model:ImageEmbeddingTask");
+var modelSchema17 = TypeModel("model:ImageEmbeddingTask");
 var ImageEmbeddingInputSchema = {
   type: "object",
   properties: {
     image: TypeSingleOrArray(TypeImageInput),
-    model: modelSchema15
+    model: modelSchema17
   },
   required: ["image", "model"],
   additionalProperties: false
@@ -4032,7 +4265,7 @@ var ImageEmbeddingOutputSchema = {
 
 class ImageEmbeddingTask extends AiVisionTask {
   static type = "ImageEmbeddingTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Image Embedding";
   static description = "Generates embeddings from images using vision models";
   static inputSchema() {
@@ -4045,16 +4278,16 @@ class ImageEmbeddingTask extends AiVisionTask {
 var imageEmbedding = (input, config) => {
   return new ImageEmbeddingTask(config).run(input);
 };
-Workflow20.prototype.imageEmbedding = CreateWorkflow20(ImageEmbeddingTask);
+Workflow22.prototype.imageEmbedding = CreateWorkflow22(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
-import { CreateWorkflow as CreateWorkflow21, Workflow as Workflow21 } from "@workglow/task-graph";
-var modelSchema16 = TypeModel("model:ImageSegmentationTask");
+import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
+var modelSchema18 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema16,
+    model: modelSchema18,
     threshold: {
       type: "number",
       title: "Threshold",
@@ -4120,7 +4353,7 @@ var ImageSegmentationOutputSchema = {
 
 class ImageSegmentationTask extends AiVisionTask {
   static type = "ImageSegmentationTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Image Segmentation";
   static description = "Segments images into regions with labels using computer vision models";
   static inputSchema() {
@@ -4133,11 +4366,11 @@ class ImageSegmentationTask extends AiVisionTask {
 var imageSegmentation = (input, config) => {
   return new ImageSegmentationTask(config).run(input);
 };
-Workflow21.prototype.imageSegmentation = CreateWorkflow21(ImageSegmentationTask);
+Workflow23.prototype.imageSegmentation = CreateWorkflow23(ImageSegmentationTask);
 
 // src/task/ImageToTextTask.ts
-import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
-var modelSchema17 = TypeModel("model:ImageToTextTask");
+import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
+var modelSchema19 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
   title: "Text",
@@ -4147,7 +4380,7 @@ var ImageToTextInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema17,
+    model: modelSchema19,
     maxTokens: {
       type: "number",
       title: "Max Tokens",
@@ -4175,7 +4408,7 @@ var ImageToTextOutputSchema = {
 
 class ImageToTextTask extends AiVisionTask {
   static type = "ImageToTextTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Image to Text";
   static description = "Generates text descriptions from images using vision-language models";
   static inputSchema() {
@@ -4188,15 +4421,15 @@ class ImageToTextTask extends AiVisionTask {
 var imageToText = (input, config) => {
   return new ImageToTextTask(config).run(input);
 };
-Workflow22.prototype.imageToText = CreateWorkflow22(ImageToTextTask);
+Workflow24.prototype.imageToText = CreateWorkflow24(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
-import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
-var modelSchema18 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
+var modelSchema20 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema18,
+    model: modelSchema20,
     detail: {
       type: "string",
       enum: ["cached_status", "files", "files_with_metadata", "dimensions"],
@@ -4209,7 +4442,7 @@ var ModelInfoInputSchema = {
 var ModelInfoOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema18,
+    model: modelSchema20,
     is_local: { type: "boolean" },
     is_remote: { type: "boolean" },
     supports_browser: { type: "boolean" },
@@ -4267,10 +4500,10 @@ class ModelInfoTask extends AiTask {
 var modelInfo = (input, config) => {
   return new ModelInfoTask(config).run(input);
 };
-Workflow23.prototype.modelInfo = CreateWorkflow23(ModelInfoTask);
+Workflow25.prototype.modelInfo = CreateWorkflow25(ModelInfoTask);
 
 // src/task/ModelSearchTask.ts
-import { CreateWorkflow as CreateWorkflow24, Task as Task10, Workflow as Workflow24 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow26, Task as Task10, Workflow as Workflow26 } from "@workglow/task-graph";
 var ModelSearchInputSchema = {
   type: "object",
   properties: {
@@ -4361,11 +4594,11 @@ class ModelSearchTask extends Task10 {
 var modelSearch = (input, config) => {
   return new ModelSearchTask(config).run(input);
 };
-Workflow24.prototype.modelSearch = CreateWorkflow24(ModelSearchTask);
+Workflow26.prototype.modelSearch = CreateWorkflow26(ModelSearchTask);
 
 // src/task/ObjectDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
-var modelSchema19 = TypeModel("model:ObjectDetectionTask");
+import { CreateWorkflow as CreateWorkflow27, Workflow as Workflow27 } from "@workglow/task-graph";
+var modelSchema21 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
   properties: {
@@ -4390,7 +4623,7 @@ var ObjectDetectionInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema19,
+    model: modelSchema21,
     labels: {
       type: "array",
       items: {
@@ -4431,7 +4664,7 @@ var ObjectDetectionOutputSchema = {
 
 class ObjectDetectionTask extends AiVisionTask {
   static type = "ObjectDetectionTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Object Detection";
   static description = "Detects objects in images using vision models. Supports zero-shot detection when labels are provided.";
   static inputSchema() {
@@ -4444,43 +4677,11 @@ class ObjectDetectionTask extends AiVisionTask {
 var objectDetection = (input, config) => {
   return new ObjectDetectionTask(config).run(input);
 };
-Workflow25.prototype.objectDetection = CreateWorkflow25(ObjectDetectionTask);
+Workflow27.prototype.objectDetection = CreateWorkflow27(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
-var modelSchema20 = TypeModel("model:PoseLandmarkerTask");
-var TypePoseLandmark = {
-  type: "object",
-  properties: {
-    x: {
-      type: "number",
-      title: "X Coordinate",
-      description: "X coordinate normalized to [0.0, 1.0]"
-    },
-    y: {
-      type: "number",
-      title: "Y Coordinate",
-      description: "Y coordinate normalized to [0.0, 1.0]"
-    },
-    z: {
-      type: "number",
-      title: "Z Coordinate",
-      description: "Z coordinate (depth)"
-    },
-    visibility: {
-      type: "number",
-      title: "Visibility",
-      description: "Likelihood of the landmark being visible within the image"
-    },
-    presence: {
-      type: "number",
-      title: "Presence",
-      description: "Likelihood of the landmark being present in the image"
-    }
-  },
-  required: ["x", "y", "z"],
-  additionalProperties: false
-};
+import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
+var modelSchema22 = TypeModel("model:PoseLandmarkerTask");
 var TypeSegmentationMask = {
   type: "object",
   properties: {
@@ -4527,7 +4728,7 @@ var PoseLandmarkerInputSchema = {
   type: "object",
   properties: {
     image: TypeImageInput,
-    model: modelSchema20,
+    model: modelSchema22,
     numPoses: {
       type: "number",
       minimum: 1,
@@ -4593,7 +4794,7 @@ var PoseLandmarkerOutputSchema = {
 
 class PoseLandmarkerTask extends AiVisionTask {
   static type = "PoseLandmarkerTask";
-  static category = "AI Vision Model";
+  static category = "AI Vision";
   static title = "Pose Landmarker";
   static description = "Detects pose landmarks in images. Identifies 33 body landmarks for pose estimation and optional segmentation.";
   static inputSchema() {
@@ -4606,10 +4807,10 @@ class PoseLandmarkerTask extends AiVisionTask {
 var poseLandmarker = (input, config) => {
   return new PoseLandmarkerTask(config).run(input);
 };
-Workflow26.prototype.poseLandmarker = CreateWorkflow26(PoseLandmarkerTask);
+Workflow28.prototype.poseLandmarker = CreateWorkflow28(PoseLandmarkerTask);
 
 // src/task/QueryExpanderTask.ts
-import { CreateWorkflow as CreateWorkflow27, Task as Task11, Workflow as Workflow27 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow29, Task as Task11, Workflow as Workflow29 } from "@workglow/task-graph";
 var QueryExpansionMethod = {
   MULTI_QUERY: "multi-query",
   SYNONYMS: "synonyms"
@@ -4779,10 +4980,10 @@ class QueryExpanderTask extends Task11 {
 var queryExpander = (input, config) => {
   return new QueryExpanderTask(config).run(input);
 };
-Workflow27.prototype.queryExpander = CreateWorkflow27(QueryExpanderTask);
+Workflow29.prototype.queryExpander = CreateWorkflow29(QueryExpanderTask);
 
 // src/task/RerankerTask.ts
-import { CreateWorkflow as CreateWorkflow28, Task as Task12, Workflow as Workflow28 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow30, Task as Task12, Workflow as Workflow30 } from "@workglow/task-graph";
 var inputSchema10 = {
   type: "object",
   properties: {
@@ -4944,11 +5145,11 @@ class RerankerTask extends Task12 {
 var reranker = (input, config) => {
   return new RerankerTask(config).run(input);
 };
-Workflow28.prototype.reranker = CreateWorkflow28(RerankerTask);
+Workflow30.prototype.reranker = CreateWorkflow30(RerankerTask);
 
 // src/task/StructuralParserTask.ts
 import { StructuralParser } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow29, Task as Task13, Workflow as Workflow29 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow31, Task as Task13, Workflow as Workflow31 } from "@workglow/task-graph";
 import { uuid4 as uuid42 } from "@workglow/util";
 var inputSchema11 = {
   type: "object",
@@ -5051,16 +5252,16 @@ class StructuralParserTask extends Task13 {
 var structuralParser = (input, config) => {
   return new StructuralParserTask(config).run(input);
 };
-Workflow29.prototype.structuralParser = CreateWorkflow29(StructuralParserTask);
+Workflow31.prototype.structuralParser = CreateWorkflow31(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow30, TaskConfigurationError as TaskConfigurationError4, TaskError, Workflow as Workflow30 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow32, TaskConfigurationError as TaskConfigurationError4, TaskError, Workflow as Workflow32 } from "@workglow/task-graph";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
-var modelSchema21 = TypeModel("model:StructuredGenerationTask");
+var modelSchema23 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema21,
+    model: modelSchema23,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5143,7 +5344,8 @@ ${errorList}
 
 class StructuredGenerationTask extends StreamingAiTask {
   static type = "StructuredGenerationTask";
-  static category = "AI Text Model";
+  static streamingPhaseLabel = "Generating";
+  static category = "AI Text";
   static title = "Structured Generation";
   static description = "Generates structured JSON output conforming to a provided schema using language models, with automatic validation and retry on mismatch";
   static inputSchema() {
@@ -5228,11 +5430,11 @@ class StructuredGenerationTask extends StreamingAiTask {
 var structuredGeneration = (input, config) => {
   return new StructuredGenerationTask(config).run(input);
 };
-Workflow30.prototype.structuredGeneration = CreateWorkflow30(StructuredGenerationTask);
+Workflow32.prototype.structuredGeneration = CreateWorkflow32(StructuredGenerationTask);
 
 // src/task/TextChunkerTask.ts
 import { ChunkRecordArraySchema as ChunkRecordArraySchema3 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow31, Task as Task14, Workflow as Workflow31 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, Task as Task14, Workflow as Workflow33 } from "@workglow/task-graph";
 var ChunkingStrategy = {
   FIXED: "fixed",
   SENTENCE: "sentence",
@@ -5482,11 +5684,11 @@ class TextChunkerTask extends Task14 {
 var textChunker = (input, config) => {
   return new TextChunkerTask(config).run(input);
 };
-Workflow31.prototype.textChunker = CreateWorkflow31(TextChunkerTask);
+Workflow33.prototype.textChunker = CreateWorkflow33(TextChunkerTask);
 
 // src/task/TextClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow32, Workflow as Workflow32 } from "@workglow/task-graph";
-var modelSchema22 = TypeModel("model:TextClassificationTask");
+import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
+var modelSchema24 = TypeModel("model:TextClassificationTask");
 var TextClassificationInputSchema = {
   type: "object",
   properties: {
@@ -5513,7 +5715,7 @@ var TextClassificationInputSchema = {
       description: "The maximum number of categories to return",
       "x-ui-group": "Configuration"
     },
-    model: modelSchema22
+    model: modelSchema24
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5550,7 +5752,7 @@ var TextClassificationOutputSchema = {
 
 class TextClassificationTask extends AiTask {
   static type = "TextClassificationTask";
-  static category = "AI Text Model";
+  static category = "AI Text";
   static title = "Text Classifier";
   static description = "Classifies text into categories using language models. Supports zero-shot classification when candidate labels are provided.";
   static inputSchema() {
@@ -5563,11 +5765,11 @@ class TextClassificationTask extends AiTask {
 var textClassification = (input, config) => {
   return new TextClassificationTask(config).run(input);
 };
-Workflow32.prototype.textClassification = CreateWorkflow32(TextClassificationTask);
+Workflow34.prototype.textClassification = CreateWorkflow34(TextClassificationTask);
 
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow33, Workflow as Workflow33 } from "@workglow/task-graph";
-var modelSchema23 = TypeModel("model:TextFillMaskTask");
+import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
+var modelSchema25 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
   properties: {
@@ -5576,7 +5778,7 @@ var TextFillMaskInputSchema = {
       title: "Text",
       description: "The text with a mask token to fill"
     },
-    model: modelSchema23
+    model: modelSchema25
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5618,7 +5820,7 @@ var TextFillMaskOutputSchema = {
 
 class TextFillMaskTask extends AiTask {
   static type = "TextFillMaskTask";
-  static category = "AI Text Model";
+  static category = "AI Text";
   static title = "Fill Mask";
   static description = "Fills masked tokens in text";
   static inputSchema() {
@@ -5631,21 +5833,21 @@ class TextFillMaskTask extends AiTask {
 var textFillMask = (input, config) => {
   return new TextFillMaskTask(config).run(input);
 };
-Workflow33.prototype.textFillMask = CreateWorkflow33(TextFillMaskTask);
+Workflow35.prototype.textFillMask = CreateWorkflow35(TextFillMaskTask);
 
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
 var generatedTextSchema2 = {
   type: "string",
   title: "Text",
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema24 = TypeModel("model:TextGenerationTask");
+var modelSchema26 = TypeModel("model:TextGenerationTask");
 var TextGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema24,
+    model: modelSchema26,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5706,7 +5908,8 @@ var TextGenerationOutputSchema = {
 
 class TextGenerationTask extends StreamingAiTask {
   static type = "TextGenerationTask";
-  static category = "AI Text Model";
+  static streamingPhaseLabel = "Generating";
+  static category = "AI Text";
   static title = "Text Generation";
   static description = "Generates text from a prompt using language models with configurable parameters";
   static inputSchema() {
@@ -5719,11 +5922,11 @@ class TextGenerationTask extends StreamingAiTask {
 var textGeneration = (input, config) => {
   return new TextGenerationTask(config).run(input);
 };
-Workflow34.prototype.textGeneration = CreateWorkflow34(TextGenerationTask);
+Workflow36.prototype.textGeneration = CreateWorkflow36(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
-var modelSchema25 = TypeModel("model:TextLanguageDetectionTask");
+import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
+var modelSchema27 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
   properties: {
@@ -5740,7 +5943,7 @@ var TextLanguageDetectionInputSchema = {
       title: "Max Languages",
       description: "The maximum number of languages to return"
     },
-    model: modelSchema25
+    model: modelSchema27
   },
   required: ["text", "model"],
   additionalProperties: false
@@ -5777,7 +5980,7 @@ var TextLanguageDetectionOutputSchema = {
 
 class TextLanguageDetectionTask extends AiTask {
   static type = "TextLanguageDetectionTask";
-  static category = "AI Text Model";
+  static category = "AI Text";
   static title = "Language Detection";
   static description = "Detects the language of text using language models";
   static inputSchema() {
@@ -5790,10 +5993,10 @@ class TextLanguageDetectionTask extends AiTask {
 var textLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(config).run(input);
 };
-Workflow35.prototype.textLanguageDetection = CreateWorkflow35(TextLanguageDetectionTask);
+Workflow37.prototype.textLanguageDetection = CreateWorkflow37(TextLanguageDetectionTask);
 
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -5810,13 +6013,13 @@ var textSchema = {
   description: "The generated text",
   "x-stream": "append"
 };
-var modelSchema26 = TypeModel("model:TextQuestionAnswerTask");
+var modelSchema28 = TypeModel("model:TextQuestionAnswerTask");
 var TextQuestionAnswerInputSchema = {
   type: "object",
   properties: {
     context: contextSchema,
     question: questionSchema,
-    model: modelSchema26
+    model: modelSchema28
   },
   required: ["context", "question", "model"],
   additionalProperties: false
@@ -5832,7 +6035,8 @@ var TextQuestionAnswerOutputSchema = {
 
 class TextQuestionAnswerTask extends StreamingAiTask {
   static type = "TextQuestionAnswerTask";
-  static category = "AI Text Model";
+  static streamingPhaseLabel = "Answering";
+  static category = "AI Text";
   static title = "Text Question Answer";
   static description = "Answers questions based on provided context using language models";
   static inputSchema() {
@@ -5845,11 +6049,11 @@ class TextQuestionAnswerTask extends StreamingAiTask {
 var textQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(config).run(input);
 };
-Workflow36.prototype.textQuestionAnswer = CreateWorkflow36(TextQuestionAnswerTask);
+Workflow38.prototype.textQuestionAnswer = CreateWorkflow38(TextQuestionAnswerTask);
 
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
-var modelSchema27 = TypeModel("model:TextRewriterTask");
+import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
+var modelSchema29 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
   properties: {
@@ -5863,7 +6067,7 @@ var TextRewriterInputSchema = {
       title: "Prompt",
       description: "The prompt to direct the rewriting"
     },
-    model: modelSchema27
+    model: modelSchema29
   },
   required: ["text", "prompt", "model"],
   additionalProperties: false
@@ -5884,7 +6088,8 @@ var TextRewriterOutputSchema = {
 
 class TextRewriterTask extends StreamingAiTask {
   static type = "TextRewriterTask";
-  static category = "AI Text Model";
+  static streamingPhaseLabel = "Rewriting";
+  static category = "AI Text";
   static title = "Text Rewriter";
   static description = "Rewrites text according to a given prompt using language models";
   static inputSchema() {
@@ -5897,11 +6102,11 @@ class TextRewriterTask extends StreamingAiTask {
 var textRewriter = (input, config) => {
   return new TextRewriterTask(config).run(input);
 };
-Workflow37.prototype.textRewriter = CreateWorkflow37(TextRewriterTask);
+Workflow39.prototype.textRewriter = CreateWorkflow39(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
-var modelSchema28 = TypeModel("model:TextTranslationTask");
+import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
+var modelSchema30 = TypeModel("model:TextTranslationTask");
 var translationTextSchema = {
   type: "string",
   title: "Text",
@@ -5928,7 +6133,7 @@ var TextTranslationInputSchema = {
       minLength: 2,
       maxLength: 2
     }),
-    model: modelSchema28
+    model: modelSchema30
   },
   required: ["text", "source_lang", "target_lang", "model"],
   additionalProperties: false
@@ -5950,7 +6155,8 @@ var TextTranslationOutputSchema = {
 
 class TextTranslationTask extends StreamingAiTask {
   static type = "TextTranslationTask";
-  static category = "AI Text Model";
+  static streamingPhaseLabel = "Translating";
+  static category = "AI Text";
   static title = "Text Translation";
   static description = "Translates text from one language to another using language models";
   static inputSchema() {
@@ -5963,10 +6169,10 @@ class TextTranslationTask extends StreamingAiTask {
 var textTranslation = (input, config) => {
   return new TextTranslationTask(config).run(input);
 };
-Workflow38.prototype.textTranslation = CreateWorkflow38(TextTranslationTask);
+Workflow40.prototype.textTranslation = CreateWorkflow40(TextTranslationTask);
 
 // src/task/ToolCallingTask.ts
-import { CreateWorkflow as CreateWorkflow39, getTaskConstructors, Workflow as Workflow39 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow41, getTaskConstructors, Workflow as Workflow41 } from "@workglow/task-graph";
 import { makeFingerprint } from "@workglow/util";
 function taskTypesToTools(taskNames, registry) {
   const constructors = getTaskConstructors(registry);
@@ -6050,11 +6256,11 @@ var ToolCallSchema = {
   required: ["id", "name", "input"],
   additionalProperties: false
 };
-var modelSchema29 = TypeModel("model:ToolCallingTask");
+var modelSchema31 = TypeModel("model:ToolCallingTask");
 var ToolCallingInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema29,
+    model: modelSchema31,
     prompt: {
       oneOf: [
         { type: "string", title: "Prompt", description: "The prompt to send to the model" },
@@ -6151,7 +6357,8 @@ var ToolCallingOutputSchema = {
 
 class ToolCallingTask extends StreamingAiTask {
   static type = "ToolCallingTask";
-  static category = "AI Text Model";
+  static streamingPhaseLabel = "Generating";
+  static category = "AI Text";
   static title = "Tool Calling";
   static description = "Sends a prompt with tool definitions to a language model and returns text along with any tool calls the model requests";
   static inputSchema() {
@@ -6198,10 +6405,10 @@ class ToolCallingTask extends StreamingAiTask {
 var toolCalling = (input, config) => {
   return new ToolCallingTask(config).run(input);
 };
-Workflow39.prototype.toolCalling = CreateWorkflow39(ToolCallingTask);
+Workflow41.prototype.toolCalling = CreateWorkflow41(ToolCallingTask);
 
 // src/task/TopicSegmenterTask.ts
-import { CreateWorkflow as CreateWorkflow40, Task as Task15, Workflow as Workflow40 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow42, Task as Task15, Workflow as Workflow42 } from "@workglow/task-graph";
 var SegmentationMethod = {
   HEURISTIC: "heuristic",
   EMBEDDING_SIMILARITY: "embedding-similarity",
@@ -6481,15 +6688,15 @@ class TopicSegmenterTask extends Task15 {
 var topicSegmenter = (input, config) => {
   return new TopicSegmenterTask(config).run(input);
 };
-Workflow40.prototype.topicSegmenter = CreateWorkflow40(TopicSegmenterTask);
+Workflow42.prototype.topicSegmenter = CreateWorkflow42(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
-var modelSchema30 = TypeModel("model");
+import { CreateWorkflow as CreateWorkflow43, Workflow as Workflow43 } from "@workglow/task-graph";
+var modelSchema32 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema30
+    model: modelSchema32
   },
   required: ["model"],
   additionalProperties: false
@@ -6497,7 +6704,7 @@ var UnloadModelInputSchema = {
 var UnloadModelOutputSchema = {
   type: "object",
   properties: {
-    model: modelSchema30
+    model: modelSchema32
   },
   required: ["model"],
   additionalProperties: false
@@ -6519,10 +6726,10 @@ class UnloadModelTask extends AiTask {
 var unloadModel = (input, config) => {
   return new UnloadModelTask(config).run(input);
 };
-Workflow41.prototype.unloadModel = CreateWorkflow41(UnloadModelTask);
+Workflow43.prototype.unloadModel = CreateWorkflow43(UnloadModelTask);
 
 // src/task/VectorQuantizeTask.ts
-import { CreateWorkflow as CreateWorkflow42, Task as Task16, Workflow as Workflow42 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow44, Task as Task16, Workflow as Workflow44 } from "@workglow/task-graph";
 import {
   normalizeNumberArray,
   TensorType,
@@ -6705,10 +6912,10 @@ class VectorQuantizeTask extends Task16 {
 var vectorQuantize = (input, config) => {
   return new VectorQuantizeTask(config).run(input);
 };
-Workflow42.prototype.vectorQuantize = CreateWorkflow42(VectorQuantizeTask);
+Workflow44.prototype.vectorQuantize = CreateWorkflow44(VectorQuantizeTask);
 
 // src/task/VectorSimilarityTask.ts
-import { CreateWorkflow as CreateWorkflow43, GraphAsTask, Workflow as Workflow43 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow45, GraphAsTask, Workflow as Workflow45 } from "@workglow/task-graph";
 import {
   cosineSimilarity,
   hammingSimilarity,
@@ -6822,7 +7029,7 @@ class VectorSimilarityTask extends GraphAsTask {
 var similarity = (input, config) => {
   return new VectorSimilarityTask(config).run(input);
 };
-Workflow43.prototype.similarity = CreateWorkflow43(VectorSimilarityTask);
+Workflow45.prototype.similarity = CreateWorkflow45(VectorSimilarityTask);
 // src/task/MessageConversion.ts
 function getInputMessages(input) {
   const messages = input.messages;
@@ -6983,8 +7190,10 @@ var registerAiTasks = () => {
     ChunkRetrievalTask,
     ChunkVectorUpsertTask,
     DownloadModelTask,
+    ImageEditTask,
     FaceDetectorTask,
     FaceLandmarkerTask,
+    ImageGenerateTask,
     GestureRecognizerTask,
     HandLandmarkerTask,
     HierarchicalChunkerTask,
@@ -7062,7 +7271,9 @@ export {
   isAllowedToolName,
   imageToText,
   imageSegmentation,
+  imageGenerate,
   imageEmbedding,
+  imageEdit,
   imageClassification,
   hierarchyJoin,
   hierarchicalChunker,
@@ -7078,6 +7289,7 @@ export {
   documentEnricher,
   countTokens,
   contextBuilder,
+  classifyProviderError,
   chunkVectorUpsert,
   chunkRetrieval,
   buildToolDescription,
@@ -7086,10 +7298,12 @@ export {
   VectorQuantizeTask,
   UnloadModelTask,
   TypeSingleOrArray,
+  TypePoseLandmark,
   TypeModelByDetail,
   TypeModelAsString,
   TypeModel,
   TypeLanguage,
+  TypeLandmark,
   TypeImageInput,
   TypeCategory,
   TypeBoundingBox,
@@ -7143,6 +7357,7 @@ export {
   QueuedAiProvider,
   QueryExpansionMethod,
   QueryExpanderTask,
+  ProviderUnsupportedFeatureError,
   PoseLandmarkerTask,
   PoseLandmarkerOutputSchema,
   PoseLandmarkerInputSchema,
@@ -7164,9 +7379,17 @@ export {
   ImageSegmentationTask,
   ImageSegmentationOutputSchema,
   ImageSegmentationInputSchema,
+  ImageGenerationProviderError,
+  ImageGenerationContentPolicyError,
+  ImageGenerateTask,
+  ImageGenerateOutputSchema,
+  ImageGenerateInputSchema,
   ImageEmbeddingTask,
   ImageEmbeddingOutputSchema,
   ImageEmbeddingInputSchema,
+  ImageEditTask,
+  ImageEditOutputSchema,
+  ImageEditInputSchema,
   ImageClassificationTask,
   ImageClassificationOutputSchema,
   ImageClassificationInputSchema,
@@ -7206,9 +7429,10 @@ export {
   AiProviderRegistry,
   AiProvider,
   AiJob,
+  AiImageOutputTask,
   AiChatTask,
   AiChatOutputSchema,
   AiChatInputSchema
 };
 
-//# debugId=54021044A3C741C364756E2164756E21
+//# debugId=E1B65A06F81AD80964756E2164756E21