@workglow/task-graph 0.0.126 → 0.1.0

package/dist/node.js

@@ -118,6 +118,7 @@ class Dataflow {
     this.error = undefined;
     this.value = undefined;
     this.stream = undefined;
+    this._compatibilityCache = undefined;
     this.emit("reset");
     this.emit("status", this.status);
   }
@@ -178,9 +179,19 @@ class Dataflow {
       targetTaskPortId: this.targetTaskPortId
     };
   }
+  _compatibilityCache;
+  invalidateCompatibilityCache() {
+    this._compatibilityCache = undefined;
+  }
   semanticallyCompatible(graph, dataflow) {
-    const targetSchema = graph.getTask(dataflow.targetTaskId).inputSchema();
-    const sourceSchema = graph.getTask(dataflow.sourceTaskId).outputSchema();
+    const sourceTask = graph.getTask(dataflow.sourceTaskId);
+    const targetTask = graph.getTask(dataflow.targetTaskId);
+    const shouldCache = !(sourceTask.constructor.hasDynamicSchemas ?? true) && !(targetTask.constructor.hasDynamicSchemas ?? true);
+    if (shouldCache && this._compatibilityCache !== undefined) {
+      return this._compatibilityCache;
+    }
+    const targetSchema = targetTask.inputSchema();
+    const sourceSchema = sourceTask.outputSchema();
     if (typeof targetSchema === "boolean") {
       if (targetSchema === false) {
         return "incompatible";
@@ -201,8 +212,11 @@ class Dataflow {
     if (sourceSchemaProperty === undefined && sourceSchema.additionalProperties === true) {
       sourceSchemaProperty = true;
     }
-    const semanticallyCompatible = areSemanticallyCompatible(sourceSchemaProperty, targetSchemaProperty);
-    return semanticallyCompatible;
+    const result = areSemanticallyCompatible(sourceSchemaProperty, targetSchemaProperty);
+    if (shouldCache) {
+      this._compatibilityCache = result;
+    }
+    return result;
   }
   get events() {
     if (!this._events) {
@@ -595,12 +609,13 @@ import { DirectedAcyclicGraph } from "@workglow/util/graph";
 import { EventEmitter as EventEmitter4, uuid4 as uuid44 } from "@workglow/util";
 
 // src/task/GraphAsTask.ts
+import { getLogger as getLogger4 } from "@workglow/util";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
 
 // src/task-graph/TaskGraphRunner.ts
 import {
   collectPropertyValues,
-  getLogger as getLogger2,
+  getLogger as getLogger3,
   getTelemetryProvider as getTelemetryProvider2,
   globalServiceRegistry as globalServiceRegistry2,
   ServiceRegistry as ServiceRegistry2,
@@ -639,7 +654,7 @@ class TaskOutputRepository {
 }
 
 // src/task/ConditionalTask.ts
-import { getLogger } from "@workglow/util";
+import { getLogger as getLogger2 } from "@workglow/util";
 
 // src/task/ConditionUtils.ts
 function evaluateCondition(fieldValue, operator, compareValue) {
@@ -717,6 +732,8 @@ import { BaseError } from "@workglow/util";
 
 class TaskError extends BaseError {
   static type = "TaskError";
+  taskType;
+  taskId;
   constructor(message) {
     super(message);
   }
@@ -750,6 +767,14 @@ class TaskTimeoutError extends TaskAbortedError {
   }
 }
 
+class TaskGraphTimeoutError extends TaskTimeoutError {
+  static type = "TaskGraphTimeoutError";
+  constructor(timeoutMs) {
+    super(timeoutMs);
+    this.message = timeoutMs ? `Graph execution timed out after ${timeoutMs}ms` : "Graph execution timed out";
+  }
+}
+
 class TaskFailedError extends TaskError {
   static type = "TaskFailedError";
   constructor(message = "Task failed") {
@@ -780,8 +805,16 @@ class TaskInvalidInputError extends TaskError {
   }
 }
 
+class TaskSerializationError extends TaskError {
+  static type = "TaskSerializationError";
+  constructor(taskType) {
+    super(`Task "${taskType}" cannot be serialized: config contains non-serializable values. ` + `Use a declarative config alternative or remove function-valued config properties.`);
+  }
+}
+
 // src/task/TaskRunner.ts
 import {
+  getLogger,
   getTelemetryProvider,
   globalServiceRegistry,
   SpanStatusCode
@@ -831,6 +864,18 @@ function getFormatPrefix(format) {
   const colonIndex = format.indexOf(":");
   return colonIndex >= 0 ? format.substring(0, colonIndex) : format;
 }
+function schemaHasFormatAnnotations(schema) {
+  if (typeof schema === "boolean")
+    return false;
+  const properties = schema.properties;
+  if (!properties || typeof properties !== "object")
+    return false;
+  for (const propSchema of Object.values(properties)) {
+    if (getSchemaFormat(propSchema) !== undefined)
+      return true;
+  }
+  return false;
+}
 async function resolveSchemaInputs(input, schema, config) {
   if (typeof schema === "boolean")
     return input;
@@ -996,6 +1041,12 @@ class TaskRunner {
     await this.handleStart(config);
     try {
       this.task.setInput(overrides);
+      const configSchema = this.task.constructor.configSchema();
+      if (schemaHasFormatAnnotations(configSchema)) {
+        const source = this.task.originalConfig ?? this.task.config;
+        const resolved = await resolveSchemaInputs({ ...source }, configSchema, { registry: this.registry });
+        Object.assign(this.task.config, resolved);
+      }
       const schema = this.task.constructor.inputSchema();
       this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
       const inputs = this.task.runInputData;
@@ -1009,6 +1060,12 @@ class TaskRunner {
       }
       let outputs;
       const isStreamable = isTaskStreamable(this.task);
+      if (!isStreamable && typeof this.task.executeStream !== "function") {
+        const streamMode = getOutputStreamMode(this.task.outputSchema());
+        if (streamMode !== "none") {
+          getLogger().warn(`Task "${this.task.type}" declares streaming output (x-stream: "${streamMode}") ` + `but does not implement executeStream(). Falling back to non-streaming execute().`);
+        }
+      }
       if (this.task.cacheable) {
         outputs = await this.outputCache?.getOutput(this.task.type, inputs);
         if (outputs) {
@@ -1047,6 +1104,12 @@ class TaskRunner {
       return this.task.runOutputData;
     }
     this.task.setInput(overrides);
+    const configSchema = this.task.constructor.configSchema();
+    if (schemaHasFormatAnnotations(configSchema)) {
+      const source = this.task.originalConfig ?? this.task.config;
+      const resolved = await resolveSchemaInputs({ ...source }, configSchema, { registry: this.registry });
+      Object.assign(this.task.config, resolved);
+    }
     const schema = this.task.constructor.inputSchema();
     this.task.runInputData = await resolveSchemaInputs(this.task.runInputData, schema, { registry: this.registry });
     await this.handleStartReactive();
@@ -1275,6 +1338,11 @@ class TaskRunner {
       this.telemetrySpan.end();
       this.telemetrySpan = undefined;
     }
+    if (typeof this.task.cleanup === "function") {
+      try {
+        await this.task.cleanup();
+      } catch {}
+    }
     this.task.emit("abort", this.task.error);
     this.task.emit("status", this.task.status);
   }
@@ -1327,7 +1395,15 @@ class TaskRunner {
     this.task.completedAt = new Date;
     this.task.progress = 100;
     this.task.status = TaskStatus.FAILED;
-    this.task.error = err instanceof TaskError ? err : new TaskFailedError(err?.message || "Task failed");
+    if (err instanceof TaskError) {
+      this.task.error = err;
+    } else {
+      this.task.error = new TaskFailedError(`Task "${this.task.type}" (${this.task.id}): ${err?.message || "Task failed"}`);
+    }
+    if (this.task.error instanceof TaskError) {
+      this.task.error.taskType ??= this.task.type;
+      this.task.error.taskId ??= this.task.id;
+    }
     this.abortController = undefined;
     if (this.telemetrySpan) {
       this.telemetrySpan.setStatus(SpanStatusCode.ERROR, this.task.error.message);
@@ -1431,6 +1507,7 @@ class Task {
   runInputData = {};
   runOutputData = {};
   config;
+  originalConfig;
   get id() {
     return this.config.id;
   }
@@ -1461,6 +1538,11 @@ class Task {
       baseConfig.id = uuid42();
     }
     this.config = this.validateAndApplyConfigDefaults(baseConfig);
+    try {
+      this.originalConfig = Object.freeze(structuredClone(this.config));
+    } catch {
+      this.originalConfig = undefined;
+    }
     this.runConfig = runConfig;
   }
   getDefaultInputsFromStaticInputDefinitions() {
@@ -1731,7 +1813,10 @@ class Task {
         const path = e.data.pointer || "";
         return `${e.message}${path ? ` (${path})` : ""}`;
       });
-      throw new TaskInvalidInputError(`Input ${JSON.stringify(Object.keys(input))} does not match schema: ${errorMessages.join(", ")}`);
+      const err = new TaskInvalidInputError(`Task "${this.type}" (${this.id}): Input ${JSON.stringify(Object.keys(input))} does not match schema: ${errorMessages.join(", ")}`);
+      err.taskType = this.type;
+      err.taskId = this.id;
+      throw err;
     }
     return true;
   }
@@ -1756,8 +1841,14 @@ class Task {
     }
     return obj;
   }
+  canSerializeConfig() {
+    return true;
+  }
   toJSON(_options) {
     const ctor = this.constructor;
+    if (!this.canSerializeConfig() || !this.originalConfig) {
+      throw new TaskSerializationError(this.type);
+    }
     const schema = ctor.configSchema();
     const schemaProperties = typeof schema !== "boolean" && schema?.properties ? schema.properties : {};
     const config = {};
@@ -1767,7 +1858,7 @@ class Task {
       if (propSchema?.["x-ui-hidden"] === true && key !== "inputSchema" && key !== "outputSchema" && key !== "extras") {
         continue;
       }
-      const value = this.config[key];
+      const value = this.originalConfig[key];
       if (value === undefined)
         continue;
       if (typeof value === "function" || typeof value === "symbol")
@@ -1851,6 +1942,11 @@ class ConditionalTask extends Task {
   static configSchema() {
     return conditionalTaskConfigSchema;
   }
+  canSerializeConfig() {
+    if (!this.config.branches)
+      return true;
+    return !this.config.branches.some((b) => typeof b.condition === "function");
+  }
   activeBranches = new Set;
   buildBranchesFromConditionConfig(conditionConfig) {
     if (!conditionConfig?.branches || conditionConfig.branches.length === 0) {
@@ -1913,7 +2009,7 @@ class ConditionalTask extends Task {
           }
         }
       } catch (error) {
-        getLogger().warn(`Condition evaluation failed for branch "${branch.id}":`, { error });
+        getLogger2().warn(`Condition evaluation failed for branch "${branch.id}":`, { error });
       }
     }
     if (this.activeBranches.size === 0 && defaultBranch) {
@@ -2203,6 +2299,8 @@ class TaskGraphRunner {
   inProgressFunctions = new Map;
   failedTaskErrors = new Map;
   telemetrySpan;
+  graphTimeoutTimer;
+  pendingGraphTimeoutError;
   constructor(graph, outputCache, processScheduler = new DependencyBasedScheduler(graph), reactiveScheduler = new TopologicalScheduler(graph)) {
     this.processScheduler = processScheduler;
     this.reactiveScheduler = reactiveScheduler;
@@ -2253,10 +2351,14 @@ class TaskGraphRunner {
       }
     } catch (err) {
       error = err;
-      getLogger2().error("Error running graph", { error });
+      getLogger3().error("Error running graph", { error });
     }
     await Promise.allSettled(Array.from(this.inProgressTasks.values()));
     await Promise.allSettled(Array.from(this.inProgressFunctions.values()));
+    if (this.pendingGraphTimeoutError) {
+      await this.handleAbort();
+      throw this.pendingGraphTimeoutError;
+    }
     if (this.failedTaskErrors.size > 0) {
       const latestError = this.failedTaskErrors.values().next().value;
       this.handleError(latestError);
@@ -2344,6 +2446,7 @@ class TaskGraphRunner {
   }
   copyInputFromEdgesToNode(task) {
     const dataflows = this.graph.getSourceDataflows(task.id);
+    dataflows.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
     for (const dataflow of dataflows) {
       this.addInputData(task, dataflow.getPortData());
     }
@@ -2352,7 +2455,7 @@ class TaskGraphRunner {
     const dataflows = this.graph.getTargetDataflows(node.id);
     for (const dataflow of dataflows) {
       const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow);
-      getLogger2().debug("pushOutputFromNodeToEdges", {
+      getLogger3().debug("pushOutputFromNodeToEdges", {
         dataflowId: dataflow.id,
         compatibility,
         resultsKeys: Object.keys(results)
@@ -2366,7 +2469,7 @@ class TaskGraphRunner {
       } else {
         const resultsKeys = Object.keys(results);
         if (resultsKeys.length > 0) {
-          getLogger2().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
+          getLogger3().warn("pushOutputFromNodeToEdge not compatible, not setting port data", {
             dataflowId: dataflow.id,
             compatibility,
             resultsKeys
@@ -2672,6 +2775,12 @@ class TaskGraphRunner {
       }
       this.graph.outputCache = this.outputCache;
     }
+    if (config?.maxTasks !== undefined && config.maxTasks > 0) {
+      const taskCount = this.graph.getTasks().length;
+      if (taskCount > config.maxTasks) {
+        throw new TaskConfigurationError(`Graph has ${taskCount} tasks, exceeding the limit of ${config.maxTasks}`);
+      }
+    }
     if (this.running || this.reactiveRunning) {
       throw new TaskConfigurationError("Graph is already running");
     }
@@ -2680,6 +2789,13 @@ class TaskGraphRunner {
     this.abortController.signal.addEventListener("abort", () => {
       this.handleAbort();
     });
+    if (config?.timeout !== undefined && config.timeout > 0) {
+      this.pendingGraphTimeoutError = undefined;
+      this.graphTimeoutTimer = setTimeout(() => {
+        this.pendingGraphTimeoutError = new TaskGraphTimeoutError(config.timeout);
+        this.abortController?.abort();
+      }, config.timeout);
+    }
     if (config?.parentSignal?.aborted) {
       this.abortController.abort();
       return;
@@ -2713,10 +2829,23 @@ class TaskGraphRunner {
     if (config?.registry !== undefined) {
       this.registry = config.registry;
     }
+    if (config?.maxTasks !== undefined && config.maxTasks > 0) {
+      const taskCount = this.graph.getTasks().length;
+      if (taskCount > config.maxTasks) {
+        throw new TaskConfigurationError(`Graph has ${taskCount} tasks, exceeding the limit of ${config.maxTasks}`);
+      }
+    }
     this.reactiveScheduler.reset();
     this.reactiveRunning = true;
   }
+  clearGraphTimeout() {
+    if (this.graphTimeoutTimer !== undefined) {
+      clearTimeout(this.graphTimeoutTimer);
+      this.graphTimeoutTimer = undefined;
+    }
+  }
   async handleComplete() {
+    this.clearGraphTimeout();
     this.running = false;
     if (this.telemetrySpan) {
       this.telemetrySpan.setStatus(SpanStatusCode2.OK);
@@ -2729,6 +2858,7 @@ class TaskGraphRunner {
     this.reactiveRunning = false;
   }
   async handleError(error) {
+    this.clearGraphTimeout();
     await Promise.allSettled(this.graph.getTasks().map(async (task) => {
       if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
         return task.abort();
@@ -2747,6 +2877,7 @@ class TaskGraphRunner {
     this.reactiveRunning = false;
   }
   async handleAbort() {
+    this.clearGraphTimeout();
     await Promise.allSettled(this.graph.getTasks().map(async (task) => {
       if (task.status === TaskStatus.PROCESSING || task.status === TaskStatus.STREAMING) {
         return task.abort();
@@ -2891,7 +3022,7 @@ class GraphAsTask extends Task {
         const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
         this._inputSchemaNode = schemaNode;
       } catch (error) {
-        console.warn(`Failed to compile input schema for ${this.type}, falling back to permissive validation:`, error);
+        getLogger4().warn(`GraphAsTask "${this.type}" (${this.id}): Failed to compile input schema, ` + `falling back to permissive validation. Inputs will NOT be validated.`, { error, taskType: this.type, taskId: this.id });
         this._inputSchemaNode = compileSchema2({});
       }
     }
@@ -3150,7 +3281,9 @@ class TaskGraph {
       outputCache: config?.outputCache || this.outputCache,
       parentSignal: config?.parentSignal || undefined,
       accumulateLeafOutputs: config?.accumulateLeafOutputs,
-      registry: config?.registry
+      registry: config?.registry,
+      timeout: config?.timeout,
+      maxTasks: config?.maxTasks
     });
   }
   runReactive(input = {}, config = {}) {
@@ -3190,18 +3323,12 @@ class TaskGraph {
     return this._dag.addEdges(addedEdges);
   }
   getDataflow(id) {
-    for (const i in this._dag.adjacency) {
-      for (const j in this._dag.adjacency[i]) {
-        const maybeEdges = this._dag.adjacency[i][j];
-        if (maybeEdges !== null) {
-          for (const edge of maybeEdges) {
-            if (this._dag.edgeIdentity(edge, "", "") == id) {
-              return edge;
-            }
-          }
-        }
+    for (const [, , edge] of this._dag.getEdges()) {
+      if (edge.id === id) {
+        return edge;
       }
     }
+    return;
   }
   getDataflows() {
     return this._dag.getEdges().map((edge) => edge[2]);
@@ -3389,9 +3516,9 @@ class TaskGraph {
   emit(name, ...args) {
     const dagEvent = EventTaskGraphToDagMapping[name];
     if (dagEvent) {
-      return this.emit_dag(name, ...args);
+      return this.emit_dag.call(this, name, ...args);
     } else {
-      return this.emit_local(name, ...args);
+      return this.emit_local.call(this, name, ...args);
     }
   }
   emit_local(name, ...args) {
@@ -3418,7 +3545,7 @@ function serialGraph(tasks, inputHandle, outputHandle) {
 // src/task-graph/Workflow.ts
 import {
   EventEmitter as EventEmitter5,
-  getLogger as getLogger3,
+  getLogger as getLogger5,
   uuid4 as uuid45
 } from "@workglow/util";
 function getLastTask(workflow) {
@@ -3566,7 +3693,7 @@ class Workflow {
           const taskSchema = task.inputSchema();
           if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
             this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-            getLogger3().error(this._error);
+            getLogger5().error(this._error);
             return;
           }
           dataflow.targetTaskId = task.id;
@@ -3591,10 +3718,10 @@ class Workflow {
         if (result.error) {
           if (this.isLoopBuilder) {
             this._error = result.error;
-            getLogger3().warn(this._error);
+            getLogger5().warn(this._error);
           } else {
             this._error = result.error + " Task not added.";
-            getLogger3().error(this._error);
+            getLogger5().error(this._error);
             this.graph.removeTask(task.id);
           }
         }
@@ -3682,7 +3809,7 @@ class Workflow {
     const nodes = this._graph.getTasks();
     if (nodes.length === 0) {
       this._error = "No tasks to remove";
-      getLogger3().error(this._error);
+      getLogger5().error(this._error);
       return this;
     }
     const lastNode = nodes[nodes.length - 1];
@@ -3713,7 +3840,7 @@ class Workflow {
     if (-index > nodes.length) {
       const errorMsg = `Back index greater than number of tasks`;
       this._error = errorMsg;
-      getLogger3().error(this._error);
+      getLogger5().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     const lastNode = nodes[nodes.length + index];
@@ -3722,13 +3849,13 @@ class Workflow {
       if (outputSchema === false && source !== DATAFLOW_ALL_PORTS) {
         const errorMsg = `Task ${lastNode.id} has schema 'false' and outputs nothing`;
         this._error = errorMsg;
-        getLogger3().error(this._error);
+        getLogger5().error(this._error);
         throw new WorkflowError(errorMsg);
       }
     } else if (!outputSchema.properties?.[source] && source !== DATAFLOW_ALL_PORTS) {
       const errorMsg = `Output ${source} not found on task ${lastNode.id}`;
       this._error = errorMsg;
-      getLogger3().error(this._error);
+      getLogger5().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     this._dataFlows.push(new Dataflow(lastNode.id, source, undefined, target));
@@ -3739,7 +3866,7 @@ class Workflow {
     const parent = getLastTask(this);
     if (!parent) {
       this._error = "onError() requires a preceding task in the workflow";
-      getLogger3().error(this._error);
+      getLogger5().error(this._error);
       throw new WorkflowError(this._error);
     }
     const handlerTask = ensureTask(handler);
@@ -3837,7 +3964,7 @@ class Workflow {
         const taskSchema = task.inputSchema();
         if (typeof taskSchema !== "boolean" && taskSchema.properties?.[dataflow.targetTaskPortId] === undefined && taskSchema.additionalProperties !== true || taskSchema === true && dataflow.targetTaskPortId !== DATAFLOW_ALL_PORTS) {
           this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
-          getLogger3().error(this._error);
+          getLogger5().error(this._error);
           return;
         }
         dataflow.targetTaskId = task.id;
@@ -3867,7 +3994,7 @@ class Workflow {
       });
       if (result.error) {
         this._error = result.error + " Task not added.";
-        getLogger3().error(this._error);
+        getLogger5().error(this._error);
         this.graph.removeTask(iteratorTask.id);
       }
     }
@@ -4713,7 +4840,11 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
   mapPartialProgress = [];
   mapPartialIterationCount = 0;
   async executeTask(input) {
-    const analysis = this.task.analyzeIterationInput(input);
+    let analysis = this.task.analyzeIterationInput(input);
+    const maxIterations = this.task.config.maxIterations;
+    if (maxIterations !== undefined && maxIterations > 0 && analysis.iterationCount > maxIterations) {
+      analysis = { ...analysis, iterationCount: maxIterations };
+    }
     if (analysis.iterationCount === 0) {
       const emptyResult = this.task.getEmptyResult();
       return this.executeTaskReactive(input, emptyResult);
@@ -4898,6 +5029,7 @@ var iteratorTaskConfigSchema = {
     ...graphAsTaskConfigSchema["properties"],
     concurrencyLimit: { type: "integer", minimum: 1 },
     batchSize: { type: "integer", minimum: 1 },
+    maxIterations: { type: "integer", minimum: 1 },
     iterationInputConfig: { type: "object", additionalProperties: true }
   },
   additionalProperties: false
@@ -4966,22 +5098,29 @@ function extractBaseSchema(schema) {
   }
   const variants = schema.oneOf ?? schema.anyOf;
   if (Array.isArray(variants)) {
+    let hasScalar = false;
+    let hasArray = false;
+    let scalarVariant;
+    let arrayVariant;
     for (const variant of variants) {
       if (typeof variant === "object") {
-        const variantType = variant.type;
-        if (variantType !== "array") {
-          return variant;
+        const v = variant;
+        if (v.type === "array" || "items" in v) {
+          hasArray = true;
+          arrayVariant = variant;
+        } else {
+          hasScalar = true;
+          scalarVariant = variant;
         }
       }
     }
-    for (const variant of variants) {
-      if (typeof variant === "object") {
-        const variantType = variant.type;
-        if (variantType === "array" && variant.items) {
-          return variant.items;
-        }
-      }
+    if (hasScalar && hasArray && variants.length === 2) {
+      return scalarVariant;
     }
+    if (!hasScalar && hasArray && arrayVariant) {
+      return arrayVariant.items;
+    }
+    return schema;
   }
   return schema;
 }
@@ -5422,6 +5561,9 @@ class WhileTask extends GraphAsTask {
     return WHILE_CONTEXT_SCHEMA;
   }
   _currentIteration = 0;
+  canSerializeConfig() {
+    return typeof this.config.condition !== "function";
+  }
   constructor(input = {}, config = {}) {
     super(input, config);
   }
@@ -5543,7 +5685,27 @@ class WhileTask extends GraphAsTask {
         parentSignal: context.signal
       });
       currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
-      if (!condition(currentOutput, this._currentIteration)) {
+      let shouldContinue;
+      try {
+        shouldContinue = condition(currentOutput, this._currentIteration);
+      } catch (err) {
+        if (err instanceof TaskFailedError) {
+          throw err;
+        }
+        const message = `${this.type}: Condition function threw at iteration ${this._currentIteration}: ${err instanceof Error ? err.message : String(err)}`;
+        const wrappedError = new TaskFailedError(message);
+        if (err instanceof Error && err.stack) {
+          if (wrappedError.stack) {
+            wrappedError.stack += `
+Caused by original error:
+${err.stack}`;
+          } else {
+            wrappedError.stack = err.stack;
+          }
+        }
+        throw wrappedError;
+      }
+      if (!shouldContinue) {
         break;
       }
       if (this.chainIterations) {
@@ -5587,7 +5749,13 @@ class WhileTask extends GraphAsTask {
         parentSignal: context.signal
       });
       currentOutput = this.subGraph.mergeExecuteOutputsToRunOutput(results, this.compoundMerge);
-      if (!condition(currentOutput, this._currentIteration)) {
+      let shouldContinue;
+      try {
+        shouldContinue = condition(currentOutput, this._currentIteration);
+      } catch (err) {
+        throw new TaskFailedError(`${this.type}: Condition function threw at iteration ${this._currentIteration}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (!shouldContinue) {
         break;
       }
       if (this.chainIterations) {
@@ -5990,205 +6158,6 @@ function getJobQueueFactory() {
 if (!globalServiceRegistry3.has(JOB_QUEUE_FACTORY)) {
   registerJobQueueFactory(defaultJobQueueFactory);
 }
-// src/task/JobQueueTask.ts
-import { Job as Job2 } from "@workglow/job-queue";
-
-// src/task/TaskQueueRegistry.ts
-var taskQueueRegistry = null;
-
-class TaskQueueRegistry {
-  queues = new Map;
-  registerQueue(queue) {
-    const queueName = queue.server.queueName;
-    if (this.queues.has(queueName)) {
-      throw new Error(`Queue with name ${queueName} already exists`);
-    }
-    this.queues.set(queueName, queue);
-  }
-  getQueue(queueName) {
-    return this.queues.get(queueName);
-  }
-  async startQueues() {
-    for (const queue of this.queues.values()) {
-      await queue.server.start();
-    }
-  }
-  async stopQueues() {
-    for (const queue of this.queues.values()) {
-      await queue.server.stop();
-    }
-  }
-  async clearQueues() {
-    for (const queue of this.queues.values()) {
-      await queue.storage.deleteAll();
-    }
-  }
-}
-function getTaskQueueRegistry() {
-  if (!taskQueueRegistry) {
-    taskQueueRegistry = new TaskQueueRegistry;
-  }
-  return taskQueueRegistry;
-}
-async function setTaskQueueRegistry(registry) {
-  if (taskQueueRegistry) {
-    await taskQueueRegistry.stopQueues();
-    await taskQueueRegistry.clearQueues();
-  }
-  taskQueueRegistry = registry;
-}
-
-// src/task/JobQueueTask.ts
-var jobQueueTaskConfigSchema = {
-  type: "object",
-  properties: {
-    ...graphAsTaskConfigSchema["properties"],
-    queue: {
-      oneOf: [{ type: "boolean" }, { type: "string" }],
-      description: "Queue handling: false=run inline, true=use default, string=explicit queue name",
-      "x-ui-hidden": true
-    }
-  },
-  additionalProperties: false
-};
-
-class JobQueueTask extends GraphAsTask {
-  static type = "JobQueueTask";
-  static canRunDirectly = true;
-  static configSchema() {
-    return jobQueueTaskConfigSchema;
-  }
-  currentQueueName;
-  currentJobId;
-  currentRunnerId;
-  jobClass;
-  constructor(input = {}, config = {}) {
-    config.queue ??= true;
-    super(input, config);
-    this.jobClass = Job2;
-  }
-  async execute(input, executeContext) {
-    let cleanup = () => {};
-    try {
-      if (this.config.queue === false && !this.constructor.canRunDirectly) {
-        throw new TaskConfigurationError(`${this.type} cannot run directly without a queue`);
-      }
-      const registeredQueue = await this.resolveQueue(input);
-      if (!registeredQueue) {
-        if (!this.constructor.canRunDirectly) {
-          const queueLabel = typeof this.config.queue === "string" ? this.config.queue : this.currentQueueName ?? this.type;
-          throw new TaskConfigurationError(`Queue ${queueLabel} not found, and ${this.type} cannot run directly`);
-        }
-        this.currentJobId = undefined;
-        const job = await this.createJob(input, this.currentQueueName);
-        cleanup = job.onJobProgress((progress, message, details) => {
-          executeContext.updateProgress(progress, message, details);
-        });
-        const output2 = await job.execute(job.input, {
-          signal: executeContext.signal,
-          updateProgress: executeContext.updateProgress.bind(this)
-        });
-        return output2;
-      }
-      const { client } = registeredQueue;
-      const jobInput = await this.getJobInput(input);
-      const handle = await client.submit(jobInput, {
-        jobRunId: this.currentRunnerId,
-        maxRetries: 10
-      });
-      this.currentJobId = handle.id;
-      this.currentQueueName = client.queueName;
-      cleanup = handle.onProgress((progress, message, details) => {
-        executeContext.updateProgress(progress, message, details);
-      });
-      const output = await handle.waitFor();
-      if (output === undefined) {
-        throw new TaskConfigurationError("Job disabled, should not happen");
-      }
-      return output;
-    } catch (err) {
-      throw new JobTaskFailedError(err);
-    } finally {
-      cleanup();
-    }
-  }
-  async getJobInput(input) {
-    return input;
-  }
-  async createJob(input, queueName) {
-    return new this.jobClass({
-      queueName: queueName ?? this.currentQueueName,
-      jobRunId: this.currentRunnerId,
-      input
-    });
-  }
-  async resolveQueue(input) {
-    const preference = this.config.queue ?? true;
-    if (preference === false) {
-      this.currentQueueName = undefined;
-      return;
-    }
-    if (typeof preference === "string") {
-      const registeredQueue2 = getTaskQueueRegistry().getQueue(preference);
-      if (registeredQueue2) {
-        this.currentQueueName = registeredQueue2.server.queueName;
-        return registeredQueue2;
-      }
-      this.currentQueueName = preference;
-      return;
-    }
-    const queueName = await this.getDefaultQueueName(input);
-    if (!queueName) {
-      this.currentQueueName = undefined;
-      return;
-    }
-    this.currentQueueName = queueName;
-    let registeredQueue = getTaskQueueRegistry().getQueue(queueName);
-    if (!registeredQueue) {
-      registeredQueue = await this.createAndRegisterQueue(queueName, input);
-      await registeredQueue.server.start();
-    }
-    return registeredQueue;
-  }
-  async getDefaultQueueName(_input) {
-    return this.type;
-  }
-  async createAndRegisterQueue(queueName, input) {
-    const factory = getJobQueueFactory();
-    let registeredQueue = await factory({
-      queueName,
-      jobClass: this.jobClass,
-      input,
-      config: this.config,
-      task: this
-    });
-    const registry = getTaskQueueRegistry();
-    try {
-      registry.registerQueue(registeredQueue);
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("already exists")) {
-        const existing = registry.getQueue(queueName);
-        if (existing) {
-          registeredQueue = existing;
-        }
-      } else {
-        throw err;
-      }
-    }
-    return registeredQueue;
-  }
-  abort() {
-    if (this.currentQueueName && this.currentJobId) {
-      const registeredQueue = getTaskQueueRegistry().getQueue(this.currentQueueName);
-      if (registeredQueue) {
-        registeredQueue.client.abort(this.currentJobId).catch((err) => {
-          console.warn(`Failed to abort remote job ${this.currentJobId}`, err);
-        });
-      }
-    }
-    super.abort();
-  }
-}
 // src/task/MapTask.ts
 var mapTaskConfigSchema = {
   type: "object",
@@ -6409,13 +6378,19 @@ function resolveTaskFromRegistry(id, _format, registry) {
 registerInputResolver("tasks", resolveTaskFromRegistry);
 
 // src/task/TaskJSON.ts
-var createSingleTaskFromJSON = (item, registry) => {
+var createSingleTaskFromJSON = (item, registry, options) => {
   if (!item.id)
     throw new TaskJSONError("Task id required");
   if (!item.type)
     throw new TaskJSONError("Task type required");
   if (item.defaults && Array.isArray(item.defaults))
     throw new TaskJSONError("Task defaults must be an object");
+  if (options?.allowedTypes) {
+    const allowed = options.allowedTypes instanceof Set ? options.allowedTypes : new Set(options.allowedTypes);
+    if (!allowed.has(item.type)) {
+      throw new TaskJSONError(`Task type "${item.type}" is not in the allowed types list`);
+    }
+  }
   const constructors = getTaskConstructors(registry);
   const taskClass = constructors.get(item.type);
   if (!taskClass)
@@ -6427,43 +6402,90 @@ var createSingleTaskFromJSON = (item, registry) => {
   const task = new taskClass(item.defaults ?? {}, taskConfig, registry ? { registry } : {});
   return task;
 };
-var createTaskFromDependencyJSON = (item, registry) => {
-  const task = createSingleTaskFromJSON(item, registry);
+var createTaskFromDependencyJSON = (item, registry, options) => {
+  const task = createSingleTaskFromJSON(item, registry, options);
   if (item.subtasks && item.subtasks.length > 0) {
     if (!(task instanceof GraphAsTask)) {
       throw new TaskConfigurationError("Subgraph is only supported for CompoundTasks");
     }
-    task.subGraph = createGraphFromDependencyJSON(item.subtasks, registry);
+    task.subGraph = createGraphFromDependencyJSON(item.subtasks, registry, options);
   }
   return task;
 };
-var createGraphFromDependencyJSON = (jsonItems, registry) => {
+var createGraphFromDependencyJSON = (jsonItems, registry, options) => {
   const subGraph = new TaskGraph;
   for (const subitem of jsonItems) {
-    subGraph.addTask(createTaskFromDependencyJSON(subitem, registry));
+    subGraph.addTask(createTaskFromDependencyJSON(subitem, registry, options));
   }
   return subGraph;
 };
-var createTaskFromGraphJSON = (item, registry) => {
-  const task = createSingleTaskFromJSON(item, registry);
+var createTaskFromGraphJSON = (item, registry, options) => {
+  const task = createSingleTaskFromJSON(item, registry, options);
   if (item.subgraph) {
     if (!(task instanceof GraphAsTask)) {
       throw new TaskConfigurationError("Subgraph is only supported for GraphAsTask");
     }
-    task.subGraph = createGraphFromGraphJSON(item.subgraph, registry);
+    task.subGraph = createGraphFromGraphJSON(item.subgraph, registry, options);
   }
   return task;
 };
-var createGraphFromGraphJSON = (graphJsonObj, registry) => {
+var createGraphFromGraphJSON = (graphJsonObj, registry, options) => {
   const subGraph = new TaskGraph;
   for (const subitem of graphJsonObj.tasks) {
-    subGraph.addTask(createTaskFromGraphJSON(subitem, registry));
+    subGraph.addTask(createTaskFromGraphJSON(subitem, registry, options));
   }
   for (const subitem of graphJsonObj.dataflows) {
     subGraph.addDataflow(new Dataflow(subitem.sourceTaskId, subitem.sourceTaskPortId, subitem.targetTaskId, subitem.targetTaskPortId));
   }
   return subGraph;
 };
+// src/task/TaskQueueRegistry.ts
+import { EventEmitter as EventEmitter6 } from "@workglow/util";
+var taskQueueRegistry = null;
+
+class TaskQueueRegistry {
+  emitter = new EventEmitter6;
+  queues = new Map;
+  registerQueue(queue) {
+    const queueName = queue.server.queueName;
+    if (this.queues.has(queueName)) {
+      throw new Error(`Queue with name ${queueName} already exists`);
+    }
+    this.queues.set(queueName, queue);
+    this.emitter.emit("queue_registered", queueName);
+  }
+  getQueue(queueName) {
+    return this.queues.get(queueName);
+  }
+  async startQueues() {
+    for (const queue of this.queues.values()) {
+      await queue.server.start();
+    }
+  }
+  async stopQueues() {
+    for (const queue of this.queues.values()) {
+      await queue.server.stop();
+    }
+  }
+  async clearQueues() {
+    for (const queue of this.queues.values()) {
+      await queue.storage.deleteAll();
+    }
+  }
+}
+function getTaskQueueRegistry() {
+  if (!taskQueueRegistry) {
+    taskQueueRegistry = new TaskQueueRegistry;
+  }
+  return taskQueueRegistry;
+}
+async function setTaskQueueRegistry(registry) {
+  if (taskQueueRegistry) {
+    await taskQueueRegistry.stopQueues();
+    await taskQueueRegistry.clearQueues();
+  }
+  taskQueueRegistry = registry;
+}
 // src/task/index.ts
 var registerBaseTasks = () => {
   const tasks = [GraphAsTask, ConditionalTask, FallbackTask, MapTask, WhileTask, ReduceTask];
@@ -6471,14 +6493,14 @@ var registerBaseTasks = () => {
   return tasks;
 };
 // src/storage/TaskGraphRepository.ts
-import { createServiceToken as createServiceToken4, EventEmitter as EventEmitter6 } from "@workglow/util";
+import { createServiceToken as createServiceToken4, EventEmitter as EventEmitter7 } from "@workglow/util";
 var TASK_GRAPH_REPOSITORY = createServiceToken4("taskgraph.taskGraphRepository");
 
 class TaskGraphRepository {
   type = "TaskGraphRepository";
   get events() {
     if (!this._events) {
-      this._events = new EventEmitter6;
+      this._events = new EventEmitter7;
     }
     return this._events;
   }
@@ -6636,6 +6658,7 @@ export {
   setTaskQueueRegistry,
   setGlobalTaskConstructors,
   serialGraph,
+  schemaHasFormatAnnotations,
   schemaAcceptsArray,
   resolveSchemaInputs,
   resetMethodNameCache,
@@ -6647,7 +6670,6 @@ export {
   parallel,
   mergeChainedOutputToInput,
   mapTaskConfigSchema,
-  jobQueueTaskConfigSchema,
   iteratorTaskConfigSchema,
   isTaskStreamable,
   isStrictArraySchema,
@@ -6704,6 +6726,7 @@ export {
   WHILE_CONTEXT_SCHEMA,
   TaskTimeoutError,
   TaskStatus,
+  TaskSerializationError,
   TaskRegistry,
   TaskQueueRegistry,
   TaskOutputTabularRepository,
@@ -6712,6 +6735,7 @@ export {
   TaskOutputPrimaryKeyNames,
   TaskJSONError,
   TaskInvalidInputError,
+  TaskGraphTimeoutError,
   TaskGraphTabularRepository,
   TaskGraphSchema,
   TaskGraphRunner,
@@ -6731,7 +6755,6 @@ export {
   PROPERTY_ARRAY,
   MapTask,
   JobTaskFailedError,
-  JobQueueTask,
   JOB_QUEUE_FACTORY,
   IteratorTaskRunner,
   IteratorTask,
@@ -6754,4 +6777,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=A032A5F42103EE2664756E2164756E21
+//# debugId=2758F4534C10DA3764756E2164756E21