@workglow/task-graph 0.0.101 → 0.0.103

package/dist/node.js

@@ -14,15 +14,29 @@ var TaskStatus = {
 var TaskConfigSchema = {
   type: "object",
   properties: {
-    id: {},
+    id: {
+      "x-ui-hidden": true
+    },
     title: { type: "string" },
     description: { type: "string" },
     cacheable: { type: "boolean" },
-    inputSchema: { type: "object", properties: {}, additionalProperties: true },
-    outputSchema: { type: "object", properties: {}, additionalProperties: true },
+    timeout: { type: "number", description: "Max execution time in milliseconds" },
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: true,
+      "x-ui-hidden": true
+    },
+    outputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: true,
+      "x-ui-hidden": true
+    },
     extras: {
       type: "object",
-      additionalProperties: true
+      additionalProperties: true,
+      "x-ui-hidden": true
     }
   },
   additionalProperties: false
@@ -227,8 +241,352 @@ class DataflowArrow extends Dataflow {
     super(sourceTaskId, sourceTaskPortId, targetTaskId, targetTaskPortId);
   }
 }
+// src/task-graph/GraphSchemaUtils.ts
+import { uuid4 } from "@workglow/util";
+function calculateNodeDepths(graph) {
+  const depths = new Map;
+  const tasks = graph.getTasks();
+  for (const task of tasks) {
+    depths.set(task.id, 0);
+  }
+  const sortedTasks = graph.topologicallySortedNodes();
+  for (const task of sortedTasks) {
+    const currentDepth = depths.get(task.id) || 0;
+    const targetTasks = graph.getTargetTasks(task.id);
+    for (const targetTask of targetTasks) {
+      const targetDepth = depths.get(targetTask.id) || 0;
+      depths.set(targetTask.id, Math.max(targetDepth, currentDepth + 1));
+    }
+  }
+  return depths;
+}
+function computeGraphInputSchema(graph, options) {
+  const trackOrigins = options?.trackOrigins ?? false;
+  const properties = {};
+  const required = [];
+  const propertyOrigins = {};
+  const tasks = graph.getTasks();
+  const startingNodes = tasks.filter((task) => graph.getSourceDataflows(task.id).length === 0);
+  for (const task of startingNodes) {
+    const taskInputSchema = task.inputSchema();
+    if (typeof taskInputSchema === "boolean") {
+      if (taskInputSchema === false) {
+        continue;
+      }
+      if (taskInputSchema === true) {
+        properties[DATAFLOW_ALL_PORTS] = {};
+        continue;
+      }
+    }
+    const taskProperties = taskInputSchema.properties || {};
+    for (const [inputName, inputProp] of Object.entries(taskProperties)) {
+      if (!properties[inputName]) {
+        properties[inputName] = inputProp;
+        if (taskInputSchema.required && taskInputSchema.required.includes(inputName)) {
+          required.push(inputName);
+        }
+        if (trackOrigins) {
+          propertyOrigins[inputName] = [task.id];
+        }
+      } else if (trackOrigins) {
+        propertyOrigins[inputName].push(task.id);
+      }
+    }
+  }
+  const sourceIds = new Set(startingNodes.map((t) => t.id));
+  for (const task of tasks) {
+    if (sourceIds.has(task.id))
+      continue;
+    const taskInputSchema = task.inputSchema();
+    if (typeof taskInputSchema === "boolean")
+      continue;
+    const requiredKeys = new Set(taskInputSchema.required || []);
+    if (requiredKeys.size === 0)
+      continue;
+    const connectedPorts = new Set(graph.getSourceDataflows(task.id).map((df) => df.targetTaskPortId));
+    for (const key of requiredKeys) {
+      if (connectedPorts.has(key))
+        continue;
+      if (properties[key]) {
+        if (trackOrigins) {
+          propertyOrigins[key].push(task.id);
+        }
+        continue;
+      }
+      if (task.defaults && task.defaults[key] !== undefined)
+        continue;
+      const prop = (taskInputSchema.properties || {})[key];
+      if (!prop || typeof prop === "boolean")
+        continue;
+      properties[key] = prop;
+      if (!required.includes(key)) {
+        required.push(key);
+      }
+      if (trackOrigins) {
+        propertyOrigins[key] = [task.id];
+      }
+    }
+  }
+  if (trackOrigins) {
+    for (const [propName, origins] of Object.entries(propertyOrigins)) {
+      const prop = properties[propName];
+      if (!prop || typeof prop === "boolean")
+        continue;
+      if (origins.length === 1) {
+        properties[propName] = { ...prop, "x-source-task-id": origins[0] };
+      } else {
+        properties[propName] = { ...prop, "x-source-task-ids": origins };
+      }
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    additionalProperties: false
+  };
+}
+function computeGraphOutputSchema(graph, options) {
+  const trackOrigins = options?.trackOrigins ?? false;
+  const properties = {};
+  const required = [];
+  const propertyOrigins = {};
+  const tasks = graph.getTasks();
+  const endingNodes = tasks.filter((task) => graph.getTargetDataflows(task.id).length === 0);
+  const depths = calculateNodeDepths(graph);
+  const maxDepth = Math.max(...endingNodes.map((task) => depths.get(task.id) || 0));
+  const lastLevelNodes = endingNodes.filter((task) => depths.get(task.id) === maxDepth);
+  const propertyCount = {};
+  const propertySchema = {};
+  for (const task of lastLevelNodes) {
+    const taskOutputSchema = task.outputSchema();
+    if (typeof taskOutputSchema === "boolean") {
+      if (taskOutputSchema === false) {
+        continue;
+      }
+      if (taskOutputSchema === true) {
+        properties[DATAFLOW_ALL_PORTS] = {};
+        continue;
+      }
+    }
+    const taskProperties = taskOutputSchema.properties || {};
+    for (const [outputName, outputProp] of Object.entries(taskProperties)) {
+      propertyCount[outputName] = (propertyCount[outputName] || 0) + 1;
+      if (!propertySchema[outputName]) {
+        propertySchema[outputName] = outputProp;
+      }
+      if (trackOrigins) {
+        if (!propertyOrigins[outputName]) {
+          propertyOrigins[outputName] = [task.id];
+        } else {
+          propertyOrigins[outputName].push(task.id);
+        }
+      }
+    }
+  }
+  for (const [outputName] of Object.entries(propertyCount)) {
+    const outputProp = propertySchema[outputName];
+    if (lastLevelNodes.length === 1) {
+      properties[outputName] = outputProp;
+    } else {
+      properties[outputName] = {
+        type: "array",
+        items: outputProp
+      };
+    }
+  }
+  if (trackOrigins) {
+    for (const [propName, origins] of Object.entries(propertyOrigins)) {
+      const prop = properties[propName];
+      if (!prop || typeof prop === "boolean")
+        continue;
+      if (origins.length === 1) {
+        properties[propName] = { ...prop, "x-source-task-id": origins[0] };
+      } else {
+        properties[propName] = { ...prop, "x-source-task-ids": origins };
+      }
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    additionalProperties: false
+  };
+}
+function stripOriginAnnotations(schema) {
+  if (typeof schema === "boolean" || !schema || typeof schema !== "object")
+    return schema;
+  const properties = schema.properties;
+  if (!properties)
+    return schema;
+  const strippedProperties = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    if (!prop || typeof prop !== "object") {
+      strippedProperties[key] = prop;
+      continue;
+    }
+    const { "x-source-task-id": _id, "x-source-task-ids": _ids, ...rest } = prop;
+    strippedProperties[key] = rest;
+  }
+  return { ...schema, properties: strippedProperties };
+}
+function getOriginTaskIds(prop) {
+  if (prop["x-source-task-ids"]) {
+    return prop["x-source-task-ids"];
+  }
+  if (prop["x-source-task-id"] !== undefined) {
+    return [prop["x-source-task-id"]];
+  }
+  return [];
+}
+function addBoundaryNodesToGraphJson(json, graph) {
+  const hasInputTask = json.tasks.some((t) => t.type === "InputTask");
+  const hasOutputTask = json.tasks.some((t) => t.type === "OutputTask");
+  if (hasInputTask && hasOutputTask) {
+    return json;
+  }
+  const inputSchema = !hasInputTask ? computeGraphInputSchema(graph, { trackOrigins: true }) : undefined;
+  const outputSchema = !hasOutputTask ? computeGraphOutputSchema(graph, { trackOrigins: true }) : undefined;
+  const prependTasks = [];
+  const appendTasks = [];
+  const inputDataflows = [];
+  const outputDataflows = [];
+  if (!hasInputTask && inputSchema) {
+    const inputTaskId = uuid4();
+    const strippedInputSchema = stripOriginAnnotations(inputSchema);
+    prependTasks.push({
+      id: inputTaskId,
+      type: "InputTask",
+      config: {
+        inputSchema: strippedInputSchema,
+        outputSchema: strippedInputSchema
+      }
+    });
+    if (typeof inputSchema !== "boolean" && inputSchema.properties) {
+      for (const [propName, prop] of Object.entries(inputSchema.properties)) {
+        if (!prop || typeof prop === "boolean")
+          continue;
+        const origins = getOriginTaskIds(prop);
+        for (const originId of origins) {
+          inputDataflows.push({
+            sourceTaskId: inputTaskId,
+            sourceTaskPortId: propName,
+            targetTaskId: originId,
+            targetTaskPortId: propName
+          });
+        }
+      }
+    }
+  }
+  if (!hasOutputTask && outputSchema) {
+    const outputTaskId = uuid4();
+    const strippedOutputSchema = stripOriginAnnotations(outputSchema);
+    appendTasks.push({
+      id: outputTaskId,
+      type: "OutputTask",
+      config: {
+        inputSchema: strippedOutputSchema,
+        outputSchema: strippedOutputSchema
+      }
+    });
+    if (typeof outputSchema !== "boolean" && outputSchema.properties) {
+      for (const [propName, prop] of Object.entries(outputSchema.properties)) {
+        if (!prop || typeof prop === "boolean")
+          continue;
+        const origins = getOriginTaskIds(prop);
+        for (const originId of origins) {
+          outputDataflows.push({
+            sourceTaskId: originId,
+            sourceTaskPortId: propName,
+            targetTaskId: outputTaskId,
+            targetTaskPortId: propName
+          });
+        }
+      }
+    }
+  }
+  return {
+    tasks: [...prependTasks, ...json.tasks, ...appendTasks],
+    dataflows: [...inputDataflows, ...json.dataflows, ...outputDataflows]
+  };
+}
+function addBoundaryNodesToDependencyJson(items, graph) {
+  const hasInputTask = items.some((t) => t.type === "InputTask");
+  const hasOutputTask = items.some((t) => t.type === "OutputTask");
+  if (hasInputTask && hasOutputTask) {
+    return items;
+  }
+  const prependItems = [];
+  const appendItems = [];
+  if (!hasInputTask) {
+    const inputSchema = computeGraphInputSchema(graph, { trackOrigins: true });
+    const inputTaskId = uuid4();
+    const strippedInputSchema = stripOriginAnnotations(inputSchema);
+    prependItems.push({
+      id: inputTaskId,
+      type: "InputTask",
+      config: {
+        inputSchema: strippedInputSchema,
+        outputSchema: strippedInputSchema
+      }
+    });
+    if (typeof inputSchema !== "boolean" && inputSchema.properties) {
+      for (const [propName, prop] of Object.entries(inputSchema.properties)) {
+        if (!prop || typeof prop === "boolean")
+          continue;
+        const origins = getOriginTaskIds(prop);
+        for (const originId of origins) {
+          const targetItem = items.find((item) => item.id === originId);
+          if (!targetItem)
+            continue;
+          if (!targetItem.dependencies) {
+            targetItem.dependencies = {};
+          }
+          const existing = targetItem.dependencies[propName];
+          const dep = { id: inputTaskId, output: propName };
+          if (!existing) {
+            targetItem.dependencies[propName] = dep;
+          } else if (Array.isArray(existing)) {
+            existing.push(dep);
+          } else {
+            targetItem.dependencies[propName] = [existing, dep];
+          }
+        }
+      }
+    }
+  }
+  if (!hasOutputTask) {
+    const outputSchema = computeGraphOutputSchema(graph, { trackOrigins: true });
+    const outputTaskId = uuid4();
+    const strippedOutputSchema = stripOriginAnnotations(outputSchema);
+    const outputDependencies = {};
+    if (typeof outputSchema !== "boolean" && outputSchema.properties) {
+      for (const [propName, prop] of Object.entries(outputSchema.properties)) {
+        if (!prop || typeof prop === "boolean")
+          continue;
+        const origins = getOriginTaskIds(prop);
+        if (origins.length === 1) {
+          outputDependencies[propName] = { id: origins[0], output: propName };
+        } else if (origins.length > 1) {
+          outputDependencies[propName] = origins.map((id) => ({ id, output: propName }));
+        }
+      }
+    }
+    appendItems.push({
+      id: outputTaskId,
+      type: "OutputTask",
+      config: {
+        inputSchema: strippedOutputSchema,
+        outputSchema: strippedOutputSchema
+      },
+      ...Object.keys(outputDependencies).length > 0 ? { dependencies: outputDependencies } : {}
+    });
+  }
+  return [...prependItems, ...items, ...appendItems];
+}
 // src/task-graph/TaskGraph.ts
-import { DirectedAcyclicGraph, EventEmitter as EventEmitter5, uuid4 as uuid44 } from "@workglow/util";
+import { DirectedAcyclicGraph, EventEmitter as EventEmitter5, uuid4 as uuid45 } from "@workglow/util";
 
 // src/task/GraphAsTask.ts
 import { compileSchema as compileSchema2 } from "@workglow/util";
@@ -236,9 +594,10 @@ import { compileSchema as compileSchema2 } from "@workglow/util";
 // src/task-graph/TaskGraphRunner.ts
 import {
   collectPropertyValues,
+  getLogger as getLogger3,
   globalServiceRegistry as globalServiceRegistry2,
   ServiceRegistry as ServiceRegistry2,
-  uuid4 as uuid42
+  uuid4 as uuid43
 } from "@workglow/util";
 
 // src/storage/TaskOutputRepository.ts
@@ -271,6 +630,9 @@ class TaskOutputRepository {
   }
 }
 
+// src/task/ConditionalTask.ts
+import { getLogger as getLogger2 } from "@workglow/util";
+
 // src/task/ConditionUtils.ts
 function evaluateCondition(fieldValue, operator, compareValue) {
   if (fieldValue === null || fieldValue === undefined) {
@@ -343,7 +705,7 @@ import {
   compileSchema,
   deepEqual,
   EventEmitter as EventEmitter3,
-  uuid4
+  uuid4 as uuid42
 } from "@workglow/util";
 
 // src/task/TaskError.ts
@@ -377,6 +739,13 @@ class TaskAbortedError extends TaskError {
   }
 }
 
+class TaskTimeoutError extends TaskAbortedError {
+  static type = "TaskTimeoutError";
+  constructor(timeoutMs) {
+    super(timeoutMs ? `Task timed out after ${timeoutMs}ms` : "Task timed out");
+  }
+}
+
 class TaskFailedError extends TaskError {
   static type = "TaskFailedError";
   constructor(message = "Task failed") {
@@ -408,7 +777,7 @@ class TaskInvalidInputError extends TaskError {
 }
 
 // src/task/TaskRunner.ts
-import { globalServiceRegistry } from "@workglow/util";
+import { getLogger, globalServiceRegistry } from "@workglow/util";
 
 // src/task/InputResolver.ts
 import { getInputResolvers } from "@workglow/util";
@@ -472,7 +841,7 @@ function getPortStreamMode(schema, portId) {
   if (!prop || typeof prop === "boolean")
     return "none";
   const xStream = prop["x-stream"];
-  if (xStream === "append" || xStream === "replace")
+  if (xStream === "append" || xStream === "replace" || xStream === "object")
     return xStream;
   return "none";
 }
@@ -487,7 +856,7 @@ function getStreamingPorts(schema) {
     if (!prop || typeof prop === "boolean")
       continue;
     const xStream = prop["x-stream"];
-    if (xStream === "append" || xStream === "replace") {
+    if (xStream === "append" || xStream === "replace" || xStream === "object") {
       result.push({ port: name, mode: xStream });
     }
   }
@@ -531,6 +900,39 @@ function edgeNeedsAccumulation(sourceSchema, sourcePort, targetSchema, targetPor
   const targetMode = getPortStreamMode(targetSchema, targetPort);
   return sourceMode !== targetMode;
 }
+function getObjectPortId(schema) {
+  if (typeof schema === "boolean")
+    return;
+  const props = schema.properties;
+  if (!props)
+    return;
+  for (const [name, prop] of Object.entries(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
+    if (prop["x-stream"] === "object")
+      return name;
+  }
+  return;
+}
+function getStructuredOutputSchemas(schema) {
+  const result = new Map;
+  if (typeof schema === "boolean")
+    return result;
+  const props = schema.properties;
+  if (!props)
+    return result;
+  for (const [name, prop] of Object.entries(props)) {
+    if (!prop || typeof prop === "boolean")
+      continue;
+    if (prop["x-structured-output"] === true) {
+      result.set(name, prop);
+    }
+  }
+  return result;
+}
+function hasStructuredOutput(schema) {
+  return getStructuredOutputSchemas(schema).size > 0;
+}
 
 // src/task/TaskRunner.ts
 class TaskRunner {
@@ -541,12 +943,17 @@ class TaskRunner {
   outputCache;
   registry = globalServiceRegistry;
   inputStreams;
+  timeoutTimer;
+  pendingTimeoutError;
   shouldAccumulate = true;
   constructor(task) {
     this.task = task;
     this.own = this.own.bind(this);
     this.handleProgress = this.handleProgress.bind(this);
   }
+  get timerLabel() {
+    return `task:${this.task.type}:${this.task.config.id}`;
+  }
   async run(overrides = {}, config = {}) {
     await this.handleStart(config);
     try {
@@ -593,7 +1000,7 @@ class TaskRunner {
       return this.task.runOutputData;
     } catch (err) {
       await this.handleError(err);
-      throw err;
+      throw this.task.error instanceof TaskTimeoutError ? this.task.error : err;
     }
   }
   async runReactive(overrides = {}) {
@@ -650,7 +1057,14 @@ class TaskRunner {
         throw new TaskError(`Task ${this.task.type} declares append streaming but no output port has x-stream: "append"`);
       }
     }
+    if (streamMode === "object") {
+      const ports = getStreamingPorts(this.task.outputSchema());
+      if (ports.length === 0) {
+        throw new TaskError(`Task ${this.task.type} declares object streaming but no output port has x-stream: "object"`);
+      }
+    }
     const accumulated = this.shouldAccumulate ? new Map : undefined;
+    const accumulatedObjects = this.shouldAccumulate ? new Map : undefined;
     let chunkCount = 0;
     let finalOutput;
     this.task.emit("stream_start");
@@ -681,6 +1095,13 @@ class TaskRunner {
           break;
         }
         case "object-delta": {
+          if (accumulatedObjects) {
+            accumulatedObjects.set(event.port, event.objectDelta);
+          }
+          this.task.runOutputData = {
+            ...this.task.runOutputData,
+            [event.port]: event.objectDelta
+          };
           this.task.emit("stream_chunk", event);
           const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
           await this.handleProgress(progress);
@@ -693,11 +1114,18 @@ class TaskRunner {
           break;
         }
         case "finish": {
-          if (accumulated) {
+          if (accumulated || accumulatedObjects) {
             const merged = { ...event.data || {} };
-            for (const [port, text] of accumulated) {
-              if (text.length > 0)
-                merged[port] = text;
+            if (accumulated) {
+              for (const [port, text] of accumulated) {
+                if (text.length > 0)
+                  merged[port] = text;
+              }
+            }
+            if (accumulatedObjects) {
+              for (const [port, obj] of accumulatedObjects) {
+                merged[port] = obj;
+              }
             }
             finalOutput = merged;
             this.task.emit("stream_chunk", { type: "finish", data: merged });
@@ -743,12 +1171,20 @@ class TaskRunner {
       this.outputCache = cache;
     }
     this.shouldAccumulate = config.shouldAccumulate !== false;
+    const timeout = this.task.config.timeout;
+    if (timeout !== undefined && timeout > 0) {
+      this.pendingTimeoutError = new TaskTimeoutError(timeout);
+      this.timeoutTimer = setTimeout(() => {
+        this.abort();
+      }, timeout);
+    }
     if (config.updateProgress) {
       this.updateProgress = config.updateProgress;
     }
     if (config.registry) {
       this.registry = config.registry;
     }
+    getLogger().time(this.timerLabel, { taskType: this.task.type, taskId: this.task.config.id });
     this.task.emit("start");
     this.task.emit("status", this.task.status);
   }
@@ -756,12 +1192,21 @@ class TaskRunner {
   async handleStartReactive() {
     this.reactiveRunning = true;
   }
+  clearTimeoutTimer() {
+    if (this.timeoutTimer !== undefined) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = undefined;
+    }
+  }
   async handleAbort() {
     if (this.task.status === TaskStatus.ABORTING)
       return;
+    this.clearTimeoutTimer();
+    getLogger().timeEnd(this.timerLabel, { taskType: this.task.type, taskId: this.task.config.id });
     this.task.status = TaskStatus.ABORTING;
     this.task.progress = 100;
-    this.task.error = new TaskAbortedError;
+    this.task.error = this.pendingTimeoutError ?? new TaskAbortedError;
+    this.pendingTimeoutError = undefined;
     this.task.emit("abort", this.task.error);
     this.task.emit("status", this.task.status);
   }
@@ -771,6 +1216,9 @@ class TaskRunner {
   async handleComplete() {
     if (this.task.status === TaskStatus.COMPLETED)
       return;
+    this.clearTimeoutTimer();
+    this.pendingTimeoutError = undefined;
+    getLogger().timeEnd(this.timerLabel, { taskType: this.task.type, taskId: this.task.config.id });
     this.task.completedAt = new Date;
     this.task.progress = 100;
     this.task.status = TaskStatus.COMPLETED;
@@ -799,6 +1247,9 @@ class TaskRunner {
       return this.handleAbort();
     if (this.task.status === TaskStatus.FAILED)
       return;
+    this.clearTimeoutTimer();
+    this.pendingTimeoutError = undefined;
+    getLogger().timeEnd(this.timerLabel, { taskType: this.task.type, taskId: this.task.config.id });
     if (this.task.hasChildren()) {
       this.task.subGraph.abort();
     }
@@ -829,6 +1280,7 @@ class Task {
   static cacheable = true;
   static hasDynamicSchemas = false;
   static passthroughInputsToOutputs = false;
+  static customizable = false;
   static inputSchema() {
     return {
       type: "object",
@@ -902,6 +1354,9 @@ class Task {
   runInputData = {};
   runOutputData = {};
   config;
+  get id() {
+    return this.config.id;
+  }
   runConfig = {};
   status = TaskStatus.PENDING;
   progress = 0;
@@ -923,9 +1378,11 @@ class Task {
     this.resetInputData();
     const title = this.constructor.title || undefined;
     const baseConfig = Object.assign({
-      id: uuid4(),
       ...title ? { title } : {}
     }, config);
+    if (baseConfig.id === undefined) {
+      baseConfig.id = uuid42();
+    }
     this.config = this.validateAndApplyConfigDefaults(baseConfig);
     this.runConfig = runConfig;
   }
@@ -935,7 +1392,7 @@ class Task {
       return {};
     }
     try {
-      const compiledSchema = this.getInputSchemaNode(this.type);
+      const compiledSchema = this.getInputSchemaNode();
       const defaultData = compiledSchema.getData(undefined, {
         addOptionalProps: true,
         removeInvalidData: false,
@@ -1053,7 +1510,7 @@ class Task {
           continue;
         const isArray = prop?.type === "array" || prop?.type === "any" && (Array.isArray(overrides[inputId]) || Array.isArray(this.runInputData[inputId]));
         if (isArray) {
-          const existingItems = Array.isArray(this.runInputData[inputId]) ? this.runInputData[inputId] : [this.runInputData[inputId]];
+          const existingItems = Array.isArray(this.runInputData[inputId]) ? this.runInputData[inputId] : this.runInputData[inputId] !== undefined ? [this.runInputData[inputId]] : [];
           const newitems = [...existingItems];
           const overrideItem = overrides[inputId];
           if (Array.isArray(overrideItem)) {
@@ -1109,25 +1566,29 @@ class Task {
     const finalOutputSchema = outputSchema ?? this.outputSchema();
     this.emit("schemaChange", finalInputSchema, finalOutputSchema);
   }
-  static _configSchemaNode = new Map;
-  static getConfigSchemaNode(type) {
+  static getConfigSchemaNode() {
     const schema = this.configSchema();
     if (!schema)
       return;
-    if (!this._configSchemaNode.has(type)) {
+    if (!Object.hasOwn(this, "__compiledConfigSchema")) {
       try {
         const schemaNode = typeof schema === "boolean" ? compileSchema(schema ? {} : { not: {} }) : compileSchema(schema);
-        this._configSchemaNode.set(type, schemaNode);
+        Object.defineProperty(this, "__compiledConfigSchema", {
+          value: schemaNode,
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
       } catch (error) {
         console.warn(`Failed to compile config schema for ${this.type}:`, error);
         return;
       }
     }
-    return this._configSchemaNode.get(type);
+    return this.__compiledConfigSchema;
   }
   validateAndApplyConfigDefaults(config) {
     const ctor = this.constructor;
-    const schemaNode = ctor.getConfigSchemaNode(this.type);
+    const schemaNode = ctor.getConfigSchemaNode();
     if (!schemaNode)
       return config;
     const result = schemaNode.validate(config);
@@ -1140,7 +1601,6 @@ class Task {
     }
     return config;
   }
-  static _inputSchemaNode = new Map;
   static generateInputSchemaNode(schema) {
     if (typeof schema === "boolean") {
       if (schema === false) {
@@ -1150,24 +1610,41 @@ class Task {
     }
     return compileSchema(schema);
   }
-  static getInputSchemaNode(type) {
-    if (!this._inputSchemaNode.has(type)) {
+  static getInputSchemaNode() {
+    if (!Object.hasOwn(this, "__compiledInputSchema")) {
       const dataPortSchema = this.inputSchema();
       const schemaNode = this.generateInputSchemaNode(dataPortSchema);
       try {
-        this._inputSchemaNode.set(type, schemaNode);
+        Object.defineProperty(this, "__compiledInputSchema", {
+          value: schemaNode,
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
       } catch (error) {
         console.warn(`Failed to compile input schema for ${this.type}, falling back to permissive validation:`, error);
-        this._inputSchemaNode.set(type, compileSchema({}));
+        Object.defineProperty(this, "__compiledInputSchema", {
+          value: compileSchema({}),
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
       }
     }
-    return this._inputSchemaNode.get(type);
+    return this.__compiledInputSchema;
   }
-  getInputSchemaNode(type) {
-    return this.constructor.getInputSchemaNode(type);
+  getInputSchemaNode() {
+    return this.constructor.getInputSchemaNode();
   }
   async validateInput(input) {
-    const schemaNode = this.getInputSchemaNode(this.type);
+    const ctor = this.constructor;
+    let schemaNode;
+    if (ctor.hasDynamicSchemas) {
+      const instanceSchema = this.inputSchema();
+      schemaNode = ctor.generateInputSchemaNode(instanceSchema);
+    } else {
+      schemaNode = this.getInputSchemaNode();
+    }
     const result = schemaNode.validate(input);
     if (!result.valid) {
       const errorMessages = result.errors.map((e) => {
@@ -1178,9 +1655,6 @@ class Task {
     }
     return true;
   }
-  id() {
-    return this.config.id;
-  }
   stripSymbols(obj) {
     if (obj === null || obj === undefined) {
       return obj;
@@ -1202,14 +1676,15 @@ class Task {
     }
     return obj;
   }
-  toJSON() {
+  toJSON(_options) {
     const extras = this.config.extras;
     const json = this.stripSymbols({
-      id: this.config.id,
+      id: this.id,
       type: this.type,
       defaults: this.defaults,
       config: {
         ...this.config.title ? { title: this.config.title } : {},
+        ...this.config.description ? { description: this.config.description } : {},
         ...this.config.inputSchema ? { inputSchema: this.config.inputSchema } : {},
         ...this.config.outputSchema ? { outputSchema: this.config.outputSchema } : {},
         ...extras && Object.keys(extras).length ? { extras } : {}
@@ -1217,8 +1692,8 @@ class Task {
     });
     return json;
   }
-  toDependencyJSON() {
-    const json = this.toJSON();
+  toDependencyJSON(options) {
+    const json = this.toJSON(options);
     return json;
   }
   hasChildren() {
@@ -1248,7 +1723,7 @@ class Task {
         this.subGraph.removeDataflow(dataflow);
       }
       for (const child of this.subGraph.getTasks()) {
-        this.subGraph.removeTask(child.config.id);
+        this.subGraph.removeTask(child.id);
       }
     }
     this.events.emit("regenerate");
@@ -1339,7 +1814,7 @@ class ConditionalTask extends Task {
           }
         }
       } catch (error) {
-        console.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) {
@@ -1504,7 +1979,7 @@ class DependencyBasedScheduler {
     if (task.status === TaskStatus.DISABLED) {
       return false;
     }
-    const sourceDataflows = this.dag.getSourceDataflows(task.config.id);
+    const sourceDataflows = this.dag.getSourceDataflows(task.id);
     if (sourceDataflows.length > 0) {
       const allIncomingDisabled = sourceDataflows.every((df) => df.status === TaskStatus.DISABLED);
       if (allIncomingDisabled) {
@@ -1631,6 +2106,10 @@ class TaskGraphRunner {
     graph.outputCache = outputCache;
     this.handleProgress = this.handleProgress.bind(this);
   }
+  runId = "";
+  get timerLabel() {
+    return `graph:${this.runId}`;
+  }
   async runGraph(input = {}, config) {
     await this.handleStart(config);
     const results = [];
@@ -1643,25 +2122,33 @@ class TaskGraphRunner {
         if (this.failedTaskErrors.size > 0) {
           break;
         }
-        const isRootTask = this.graph.getSourceDataflows(task.config.id).length === 0;
+        const isRootTask = this.graph.getSourceDataflows(task.id).length === 0;
         const runAsync = async () => {
+          let errorRouted = false;
           try {
             const taskInput = isRootTask ? input : this.filterInputForTask(task, input);
             const taskPromise = this.runTask(task, taskInput);
-            this.inProgressTasks.set(task.config.id, taskPromise);
+            this.inProgressTasks.set(task.id, taskPromise);
             const taskResult = await taskPromise;
-            if (this.graph.getTargetDataflows(task.config.id).length === 0) {
+            if (this.graph.getTargetDataflows(task.id).length === 0) {
               results.push(taskResult);
             }
           } catch (error2) {
-            this.failedTaskErrors.set(task.config.id, error2);
+            if (this.hasErrorOutputEdges(task)) {
+              errorRouted = true;
+              this.pushErrorOutputToEdges(task);
+            } else {
+              this.failedTaskErrors.set(task.id, error2);
+            }
           } finally {
-            this.pushStatusFromNodeToEdges(this.graph, task);
-            this.pushErrorFromNodeToEdges(this.graph, task);
-            this.processScheduler.onTaskCompleted(task.config.id);
+            if (!errorRouted) {
+              this.pushStatusFromNodeToEdges(this.graph, task);
+              this.pushErrorFromNodeToEdges(this.graph, task);
+            }
+            this.processScheduler.onTaskCompleted(task.id);
           }
         };
-        this.inProgressFunctions.set(Symbol(task.config.id), runAsync());
+        this.inProgressFunctions.set(Symbol(task.id), runAsync());
       }
     } catch (err) {
       error = err;
@@ -1685,7 +2172,7 @@ class TaskGraphRunner {
     const results = [];
     try {
       for await (const task of this.reactiveScheduler.tasks()) {
-        const isRootTask = this.graph.getSourceDataflows(task.config.id).length === 0;
+        const isRootTask = this.graph.getSourceDataflows(task.id).length === 0;
         if (task.status === TaskStatus.PENDING) {
           task.resetInputData();
           this.copyInputFromEdgesToNode(task);
@@ -1693,9 +2180,9 @@ class TaskGraphRunner {
         const taskInput = isRootTask ? input : {};
         const taskResult = await task.runReactive(taskInput);
         await this.pushOutputFromNodeToEdges(task, taskResult);
-        if (this.graph.getTargetDataflows(task.config.id).length === 0) {
+        if (this.graph.getTargetDataflows(task.id).length === 0) {
           results.push({
-            id: task.config.id,
+            id: task.id,
             type: task.constructor.runtype || task.constructor.type,
             data: taskResult
           });
@@ -1715,7 +2202,7 @@ class TaskGraphRunner {
     await this.handleDisable();
   }
   filterInputForTask(task, input) {
-    const sourceDataflows = this.graph.getSourceDataflows(task.config.id);
+    const sourceDataflows = this.graph.getSourceDataflows(task.id);
     const connectedInputs = new Set(sourceDataflows.map((df) => df.targetTaskPortId));
     const allPortsConnected = connectedInputs.has(DATAFLOW_ALL_PORTS);
     const filteredInput = {};
@@ -1754,13 +2241,13 @@ class TaskGraphRunner {
     throw new TaskConfigurationError(`Unknown compound merge strategy: ${compoundMerge}`);
   }
   copyInputFromEdgesToNode(task) {
-    const dataflows = this.graph.getSourceDataflows(task.config.id);
+    const dataflows = this.graph.getSourceDataflows(task.id);
     for (const dataflow of dataflows) {
       this.addInputData(task, dataflow.getPortData());
     }
   }
   async pushOutputFromNodeToEdges(node, results) {
-    const dataflows = this.graph.getTargetDataflows(node.config.id);
+    const dataflows = this.graph.getTargetDataflows(node.id);
     for (const dataflow of dataflows) {
       const compatibility = dataflow.semanticallyCompatible(this.graph, dataflow);
       if (compatibility === "static") {
@@ -1775,7 +2262,7 @@ class TaskGraphRunner {
   pushStatusFromNodeToEdges(graph, node, status) {
     if (!node?.config?.id)
       return;
-    const dataflows = graph.getTargetDataflows(node.config.id);
+    const dataflows = graph.getTargetDataflows(node.id);
     const effectiveStatus = status ?? node.status;
     if (node instanceof ConditionalTask && effectiveStatus === TaskStatus.COMPLETED) {
       const branches = node.config.branches ?? [];
@@ -1806,10 +2293,31 @@ class TaskGraphRunner {
   pushErrorFromNodeToEdges(graph, node) {
     if (!node?.config?.id)
       return;
-    graph.getTargetDataflows(node.config.id).forEach((dataflow) => {
+    graph.getTargetDataflows(node.id).forEach((dataflow) => {
       dataflow.error = node.error;
     });
   }
+  hasErrorOutputEdges(task) {
+    const dataflows = this.graph.getTargetDataflows(task.id);
+    return dataflows.some((df) => df.sourceTaskPortId === DATAFLOW_ERROR_PORT);
+  }
+  pushErrorOutputToEdges(task) {
+    const taskError = task.error;
+    const errorData = {
+      error: taskError?.message ?? "Unknown error",
+      errorType: taskError?.constructor?.type ?? "TaskError"
+    };
+    const dataflows = this.graph.getTargetDataflows(task.id);
+    for (const df of dataflows) {
+      if (df.sourceTaskPortId === DATAFLOW_ERROR_PORT) {
+        df.value = errorData;
+        df.setStatus(TaskStatus.COMPLETED);
+      } else {
+        df.setStatus(TaskStatus.DISABLED);
+      }
+    }
+    this.propagateDisabledStatus(this.graph);
+  }
   propagateDisabledStatus(graph) {
     let changed = true;
     while (changed) {
@@ -1818,7 +2326,7 @@ class TaskGraphRunner {
         if (task.status !== TaskStatus.PENDING) {
           continue;
         }
-        const incomingDataflows = graph.getSourceDataflows(task.config.id);
+        const incomingDataflows = graph.getSourceDataflows(task.id);
         if (incomingDataflows.length === 0) {
           continue;
         }
@@ -1829,10 +2337,10 @@ class TaskGraphRunner {
           task.completedAt = new Date;
           task.emit("disabled");
           task.emit("status", task.status);
-          graph.getTargetDataflows(task.config.id).forEach((dataflow) => {
+          graph.getTargetDataflows(task.id).forEach((dataflow) => {
             dataflow.setStatus(TaskStatus.DISABLED);
           });
-          this.processScheduler.onTaskCompleted(task.config.id);
+          this.processScheduler.onTaskCompleted(task.id);
           changed = true;
         }
       }
@@ -1841,7 +2349,7 @@ class TaskGraphRunner {
   taskNeedsAccumulation(task) {
     if (this.outputCache)
       return true;
-    const outEdges = this.graph.getTargetDataflows(task.config.id);
+    const outEdges = this.graph.getTargetDataflows(task.id);
     if (outEdges.length === 0)
       return this.accumulateLeafOutputs;
     const outSchema = task.outputSchema();
@@ -1864,7 +2372,7 @@ class TaskGraphRunner {
   async runTask(task, input) {
     const isStreamable = isTaskStreamable(task);
     if (isStreamable) {
-      const dataflows = this.graph.getSourceDataflows(task.config.id);
+      const dataflows = this.graph.getSourceDataflows(task.id);
       const streamingEdges = dataflows.filter((df) => df.stream !== undefined);
       if (streamingEdges.length > 0) {
         const inputStreams = new Map;
@@ -1889,13 +2397,13 @@ class TaskGraphRunner {
     });
     await this.pushOutputFromNodeToEdges(task, results);
     return {
-      id: task.config.id,
+      id: task.id,
       type: task.constructor.runtype || task.constructor.type,
       data: results
     };
   }
   async awaitStreamInputs(task) {
-    const dataflows = this.graph.getSourceDataflows(task.config.id);
+    const dataflows = this.graph.getSourceDataflows(task.id);
     const streamPromises = dataflows.filter((df) => df.stream !== undefined).map((df) => df.awaitStreamValue());
     if (streamPromises.length > 0) {
       await Promise.all(streamPromises);
@@ -1910,17 +2418,17 @@ class TaskGraphRunner {
         streamingNotified = true;
         this.pushStatusFromNodeToEdges(this.graph, task, TaskStatus.STREAMING);
         this.pushStreamToEdges(task, streamMode);
-        this.processScheduler.onTaskStreaming(task.config.id);
+        this.processScheduler.onTaskStreaming(task.id);
       }
     };
     const onStreamStart = () => {
-      this.graph.emit("task_stream_start", task.config.id);
+      this.graph.emit("task_stream_start", task.id);
     };
     const onStreamChunk = (event) => {
-      this.graph.emit("task_stream_chunk", task.config.id, event);
+      this.graph.emit("task_stream_chunk", task.id, event);
     };
     const onStreamEnd = (output) => {
-      this.graph.emit("task_stream_end", task.config.id, output);
+      this.graph.emit("task_stream_end", task.id, output);
     };
     task.on("status", onStatus);
     task.on("stream_start", onStreamStart);
@@ -1935,7 +2443,7 @@ class TaskGraphRunner {
       });
       await this.pushOutputFromNodeToEdges(task, results);
       return {
-        id: task.config.id,
+        id: task.id,
         type: task.constructor.runtype || task.constructor.type,
         data: results
       };
@@ -1973,7 +2481,7 @@ class TaskGraphRunner {
     });
   }
   pushStreamToEdges(task, streamMode) {
-    const targetDataflows = this.graph.getTargetDataflows(task.config.id);
+    const targetDataflows = this.graph.getTargetDataflows(task.id);
     if (targetDataflows.length === 0)
       return;
     const groups = new Map;
@@ -2064,11 +2572,15 @@ class TaskGraphRunner {
         this.abortController?.abort();
       }, { once: true });
     }
-    this.resetGraph(this.graph, uuid42());
+    this.runId = uuid43();
+    this.resetGraph(this.graph, this.runId);
     this.processScheduler.reset();
     this.inProgressTasks.clear();
     this.inProgressFunctions.clear();
     this.failedTaskErrors.clear();
+    const logger = getLogger3();
+    logger.group(this.timerLabel, { graph: this.graph });
+    logger.time(this.timerLabel);
     this.graph.emit("start");
   }
   async handleStartReactive() {
@@ -2080,6 +2592,9 @@ class TaskGraphRunner {
   }
   async handleComplete() {
     this.running = false;
+    const logger = getLogger3();
+    logger.timeEnd(this.timerLabel);
+    logger.groupEnd();
     this.graph.emit("complete");
   }
   async handleCompleteReactive() {
@@ -2092,6 +2607,9 @@ class TaskGraphRunner {
       }
     }));
     this.running = false;
+    const logger = getLogger3();
+    logger.timeEnd(this.timerLabel);
+    logger.groupEnd();
     this.graph.emit("error", error);
   }
   async handleErrorReactive() {
@@ -2104,6 +2622,9 @@ class TaskGraphRunner {
       }
     });
     this.running = false;
+    const logger = getLogger3();
+    logger.timeEnd(this.timerLabel);
+    logger.groupEnd();
     this.graph.emit("abort");
   }
   async handleAbortReactive() {
@@ -2179,7 +2700,7 @@ var graphAsTaskConfigSchema = {
   type: "object",
   properties: {
     ...TaskConfigSchema["properties"],
-    compoundMerge: { type: "string" }
+    compoundMerge: { type: "string", "x-ui-hidden": true }
   },
   additionalProperties: false
 };
@@ -2218,118 +2739,27 @@ class GraphAsTask extends Task {
     if (!this.hasChildren()) {
       return this.constructor.inputSchema();
     }
-    const properties = {};
-    const required = [];
-    const tasks = this.subGraph.getTasks();
-    const startingNodes = tasks.filter((task) => this.subGraph.getSourceDataflows(task.config.id).length === 0);
-    for (const task of startingNodes) {
-      const taskInputSchema = task.inputSchema();
-      if (typeof taskInputSchema === "boolean") {
-        if (taskInputSchema === false) {
-          continue;
-        }
-        if (taskInputSchema === true) {
-          properties[DATAFLOW_ALL_PORTS] = {};
-          continue;
-        }
-      }
-      const taskProperties = taskInputSchema.properties || {};
-      for (const [inputName, inputProp] of Object.entries(taskProperties)) {
-        if (!properties[inputName]) {
-          properties[inputName] = inputProp;
-          if (taskInputSchema.required && taskInputSchema.required.includes(inputName)) {
-            required.push(inputName);
-          }
-        }
-      }
-    }
-    return {
-      type: "object",
-      properties,
-      ...required.length > 0 ? { required } : {},
-      additionalProperties: false
-    };
+    return computeGraphInputSchema(this.subGraph);
   }
   _inputSchemaNode;
-  getInputSchemaNode(type) {
+  getInputSchemaNode() {
     if (!this._inputSchemaNode) {
-      const dataPortSchema = this.inputSchema();
-      const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
       try {
+        const dataPortSchema = this.inputSchema();
+        const schemaNode = Task.generateInputSchemaNode(dataPortSchema);
         this._inputSchemaNode = schemaNode;
       } catch (error) {
-        console.warn(`Failed to compile input schema for ${type}, falling back to permissive validation:`, error);
+        console.warn(`Failed to compile input schema for ${this.type}, falling back to permissive validation:`, error);
         this._inputSchemaNode = compileSchema2({});
       }
     }
     return this._inputSchemaNode;
   }
-  calculateNodeDepths() {
-    const depths = new Map;
-    const tasks = this.subGraph.getTasks();
-    for (const task of tasks) {
-      depths.set(task.config.id, 0);
-    }
-    const sortedTasks = this.subGraph.topologicallySortedNodes();
-    for (const task of sortedTasks) {
-      const currentDepth = depths.get(task.config.id) || 0;
-      const targetTasks = this.subGraph.getTargetTasks(task.config.id);
-      for (const targetTask of targetTasks) {
-        const targetDepth = depths.get(targetTask.config.id) || 0;
-        depths.set(targetTask.config.id, Math.max(targetDepth, currentDepth + 1));
-      }
-    }
-    return depths;
-  }
   outputSchema() {
     if (!this.hasChildren()) {
       return this.constructor.outputSchema();
     }
-    const properties = {};
-    const required = [];
-    const tasks = this.subGraph.getTasks();
-    const endingNodes = tasks.filter((task) => this.subGraph.getTargetDataflows(task.config.id).length === 0);
-    const depths = this.calculateNodeDepths();
-    const maxDepth = Math.max(...endingNodes.map((task) => depths.get(task.config.id) || 0));
-    const lastLevelNodes = endingNodes.filter((task) => depths.get(task.config.id) === maxDepth);
-    const propertyCount = {};
-    const propertySchema = {};
-    for (const task of lastLevelNodes) {
-      const taskOutputSchema = task.outputSchema();
-      if (typeof taskOutputSchema === "boolean") {
-        if (taskOutputSchema === false) {
-          continue;
-        }
-        if (taskOutputSchema === true) {
-          properties[DATAFLOW_ALL_PORTS] = {};
-          continue;
-        }
-      }
-      const taskProperties = taskOutputSchema.properties || {};
-      for (const [outputName, outputProp] of Object.entries(taskProperties)) {
-        propertyCount[outputName] = (propertyCount[outputName] || 0) + 1;
-        if (!propertySchema[outputName]) {
-          propertySchema[outputName] = outputProp;
-        }
-      }
-    }
-    for (const [outputName, count] of Object.entries(propertyCount)) {
-      const outputProp = propertySchema[outputName];
-      if (lastLevelNodes.length === 1) {
-        properties[outputName] = outputProp;
-      } else {
-        properties[outputName] = {
-          type: "array",
-          items: outputProp
-        };
-      }
-    }
-    return {
-      type: "object",
-      properties,
-      ...required.length > 0 ? { required } : {},
-      additionalProperties: false
-    };
+    return computeGraphOutputSchema(this.subGraph);
   }
   resetInputData() {
     super.resetInputData();
@@ -2364,8 +2794,8 @@ class GraphAsTask extends Task {
       const endingNodeIds = new Set;
       const tasks = this.subGraph.getTasks();
       for (const task of tasks) {
-        if (this.subGraph.getTargetDataflows(task.config.id).length === 0) {
-          endingNodeIds.add(task.config.id);
+        if (this.subGraph.getTargetDataflows(task.id).length === 0) {
+          endingNodeIds.add(task.id);
         }
       }
       const eventQueue = [];
@@ -2409,32 +2839,36 @@ class GraphAsTask extends Task {
     this._inputSchemaNode = undefined;
     this.events.emit("regenerate");
   }
-  toJSON() {
-    let json = super.toJSON();
+  toJSON(options) {
+    let json = super.toJSON(options);
     const hasChildren = this.hasChildren();
     if (hasChildren) {
       json = {
         ...json,
         merge: this.compoundMerge,
-        subgraph: this.subGraph.toJSON()
+        subgraph: this.subGraph.toJSON(options)
       };
     }
     return json;
   }
-  toDependencyJSON() {
-    const json = this.toJSON();
+  toDependencyJSON(options) {
+    const json = this.toJSON(options);
     if (this.hasChildren()) {
       if ("subgraph" in json) {
         delete json.subgraph;
       }
-      return { ...json, subtasks: this.subGraph.toDependencyJSON() };
+      return { ...json, subtasks: this.subGraph.toDependencyJSON(options) };
     }
     return json;
   }
 }
 
 // src/task-graph/Workflow.ts
-import { EventEmitter as EventEmitter4, uuid4 as uuid43 } from "@workglow/util";
+import {
+  EventEmitter as EventEmitter4,
+  getLogger as getLogger4,
+  uuid4 as uuid44
+} from "@workglow/util";
 function CreateWorkflow(taskClass) {
   return Workflow.createWorkflow(taskClass);
 }
@@ -2535,43 +2969,48 @@ class Workflow {
     const helper = function(input = {}, config = {}) {
       this._error = "";
       const parent = getLastTask(this);
-      const task = this.addTaskToGraph(taskClass, input, { id: uuid43(), ...config });
+      const task = this.addTaskToGraph(taskClass, input, { id: uuid44(), ...config });
       if (this._dataFlows.length > 0) {
         this._dataFlows.forEach((dataflow) => {
           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.config.id}`;
-            console.error(this._error);
+            this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
+            getLogger4().error(this._error);
             return;
           }
-          dataflow.targetTaskId = task.config.id;
+          dataflow.targetTaskId = task.id;
           this.graph.addDataflow(dataflow);
         });
         this._dataFlows = [];
       }
-      if (parent && this.graph.getTargetDataflows(parent.config.id).length === 0) {
+      if (parent) {
         const nodes = this._graph.getTasks();
-        const parentIndex = nodes.findIndex((n) => n.config.id === parent.config.id);
+        const parentIndex = nodes.findIndex((n) => n.id === parent.id);
         const earlierTasks = [];
         for (let i = parentIndex - 1;i >= 0; i--) {
           earlierTasks.push(nodes[i]);
         }
         const providedInputKeys = new Set(Object.keys(input || {}));
+        const connectedInputKeys = new Set(this.graph.getSourceDataflows(task.id).map((df) => df.targetTaskPortId));
         const result = Workflow.autoConnect(this.graph, parent, task, {
           providedInputKeys,
+          connectedInputKeys,
           earlierTasks
         });
         if (result.error) {
           if (this.isLoopBuilder) {
             this._error = result.error;
-            console.warn(this._error);
+            getLogger4().warn(this._error);
           } else {
             this._error = result.error + " Task not added.";
-            console.error(this._error);
-            this.graph.removeTask(task.config.id);
+            getLogger4().error(this._error);
+            this.graph.removeTask(task.id);
           }
         }
       }
+      if (!this._error) {
+        Workflow.updateBoundaryTaskSchemas(this._graph);
+      }
       return this;
     };
     helper.type = taskClass.runtype ?? taskClass.type;
@@ -2651,18 +3090,18 @@ class Workflow {
     const nodes = this._graph.getTasks();
     if (nodes.length === 0) {
       this._error = "No tasks to remove";
-      console.error(this._error);
+      getLogger4().error(this._error);
       return this;
     }
     const lastNode = nodes[nodes.length - 1];
-    this._graph.removeTask(lastNode.config.id);
+    this._graph.removeTask(lastNode.id);
     return this;
   }
-  toJSON() {
-    return this._graph.toJSON();
+  toJSON(options = { withBoundaryNodes: true }) {
+    return this._graph.toJSON(options);
   }
-  toDependencyJSON() {
-    return this._graph.toDependencyJSON();
+  toDependencyJSON(options = { withBoundaryNodes: true }) {
+    return this._graph.toDependencyJSON(options);
   }
   pipe(...args) {
     return pipe(args, this);
@@ -2682,25 +3121,40 @@ class Workflow {
     if (-index > nodes.length) {
       const errorMsg = `Back index greater than number of tasks`;
       this._error = errorMsg;
-      console.error(this._error);
+      getLogger4().error(this._error);
       throw new WorkflowError(errorMsg);
     }
     const lastNode = nodes[nodes.length + index];
     const outputSchema = lastNode.outputSchema();
     if (typeof outputSchema === "boolean") {
       if (outputSchema === false && source !== DATAFLOW_ALL_PORTS) {
-        const errorMsg = `Task ${lastNode.config.id} has schema 'false' and outputs nothing`;
+        const errorMsg = `Task ${lastNode.id} has schema 'false' and outputs nothing`;
         this._error = errorMsg;
-        console.error(this._error);
+        getLogger4().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.config.id}`;
+      const errorMsg = `Output ${source} not found on task ${lastNode.id}`;
       this._error = errorMsg;
-      console.error(this._error);
+      getLogger4().error(this._error);
       throw new WorkflowError(errorMsg);
     }
-    this._dataFlows.push(new Dataflow(lastNode.config.id, source, undefined, target));
+    this._dataFlows.push(new Dataflow(lastNode.id, source, undefined, target));
+    return this;
+  }
+  onError(handler) {
+    this._error = "";
+    const parent = getLastTask(this);
+    if (!parent) {
+      this._error = "onError() requires a preceding task in the workflow";
+      getLogger4().error(this._error);
+      throw new WorkflowError(this._error);
+    }
+    const handlerTask = ensureTask(handler);
+    this.graph.addTask(handlerTask);
+    const dataflow = new Dataflow(parent.id, DATAFLOW_ERROR_PORT, handlerTask.id, DATAFLOW_ALL_PORTS);
+    this.graph.addDataflow(dataflow);
+    this.events.emit("changed", handlerTask.id);
     return this;
   }
   toTaskGraph() {
@@ -2785,16 +3239,16 @@ class Workflow {
   addLoopTask(taskClass, config = {}) {
     this._error = "";
     const parent = getLastTask(this);
-    const task = this.addTaskToGraph(taskClass, {}, { id: uuid43(), ...config });
+    const task = this.addTaskToGraph(taskClass, {}, { id: uuid44(), ...config });
     if (this._dataFlows.length > 0) {
       this._dataFlows.forEach((dataflow) => {
         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.config.id}`;
-          console.error(this._error);
+          this._error = `Input ${dataflow.targetTaskPortId} not found on task ${task.id}`;
+          getLogger4().error(this._error);
           return;
         }
-        dataflow.targetTaskId = task.config.id;
+        dataflow.targetTaskId = task.id;
         this.graph.addDataflow(dataflow);
       });
       this._dataFlows = [];
@@ -2809,9 +3263,9 @@ class Workflow {
     if (!pending)
       return;
     const { parent, iteratorTask } = pending;
-    if (this.graph.getTargetDataflows(parent.config.id).length === 0) {
+    if (this.graph.getTargetDataflows(parent.id).length === 0) {
       const nodes = this._graph.getTasks();
-      const parentIndex = nodes.findIndex((n) => n.config.id === parent.config.id);
+      const parentIndex = nodes.findIndex((n) => n.id === parent.id);
       const earlierTasks = [];
       for (let i = parentIndex - 1;i >= 0; i--) {
         earlierTasks.push(nodes[i]);
@@ -2821,8 +3275,81 @@ class Workflow {
       });
       if (result.error) {
         this._error = result.error + " Task not added.";
-        console.error(this._error);
-        this.graph.removeTask(iteratorTask.config.id);
+        getLogger4().error(this._error);
+        this.graph.removeTask(iteratorTask.id);
+      }
+    }
+  }
+  static updateBoundaryTaskSchemas(graph) {
+    const tasks = graph.getTasks();
+    for (const task of tasks) {
+      if (task.type === "InputTask") {
+        const outgoing = graph.getTargetDataflows(task.id);
+        if (outgoing.length === 0)
+          continue;
+        const properties = {};
+        const required = [];
+        for (const df of outgoing) {
+          const targetTask = graph.getTask(df.targetTaskId);
+          if (!targetTask)
+            continue;
+          const targetSchema = targetTask.inputSchema();
+          if (typeof targetSchema === "boolean")
+            continue;
+          const prop = targetSchema.properties?.[df.targetTaskPortId];
+          if (prop && typeof prop !== "boolean") {
+            properties[df.sourceTaskPortId] = prop;
+            if (targetSchema.required?.includes(df.targetTaskPortId)) {
+              if (!required.includes(df.sourceTaskPortId)) {
+                required.push(df.sourceTaskPortId);
+              }
+            }
+          }
+        }
+        const schema = {
+          type: "object",
+          properties,
+          ...required.length > 0 ? { required } : {},
+          additionalProperties: false
+        };
+        task.config = {
+          ...task.config,
+          inputSchema: schema,
+          outputSchema: schema
+        };
+      }
+      if (task.type === "OutputTask") {
+        const incoming = graph.getSourceDataflows(task.id);
+        if (incoming.length === 0)
+          continue;
+        const properties = {};
+        const required = [];
+        for (const df of incoming) {
+          const sourceTask = graph.getTask(df.sourceTaskId);
+          if (!sourceTask)
+            continue;
+          const sourceSchema = sourceTask.outputSchema();
+          if (typeof sourceSchema === "boolean")
+            continue;
+          const prop = sourceSchema.properties?.[df.sourceTaskPortId];
+          if (prop && typeof prop !== "boolean") {
+            properties[df.targetTaskPortId] = prop;
+            if (sourceSchema.required?.includes(df.sourceTaskPortId) && !required.includes(df.targetTaskPortId)) {
+              required.push(df.targetTaskPortId);
+            }
+          }
+        }
+        const schema = {
+          type: "object",
+          properties,
+          ...required.length > 0 ? { required } : {},
+          additionalProperties: false
+        };
+        task.config = {
+          ...task.config,
+          inputSchema: schema,
+          outputSchema: schema
+        };
       }
     }
   }
@@ -2832,6 +3359,7 @@ class Workflow {
     const sourceSchema = sourceTask.outputSchema();
     const targetSchema = targetTask.inputSchema();
     const providedInputKeys = options?.providedInputKeys ?? new Set;
+    const connectedInputKeys = options?.connectedInputKeys ?? new Set;
     const earlierTasks = options?.earlierTasks ?? [];
     const getSpecificTypeIdentifiers = (schema) => {
       const formats = new Set;
@@ -2907,18 +3435,33 @@ class Workflow {
       if (typeof fromSchema === "object") {
         if (toSchema === true || typeof toSchema === "object" && toSchema.additionalProperties === true) {
           for (const fromOutputPortId of Object.keys(fromSchema.properties || {})) {
+            if (matches.has(fromOutputPortId))
+              continue;
             matches.set(fromOutputPortId, fromOutputPortId);
             graph.addDataflow(new Dataflow(fromTaskId, fromOutputPortId, toTaskId, fromOutputPortId));
           }
           return;
         }
       }
+      if (typeof fromSchema === "object" && fromSchema.additionalProperties === true && typeof toSchema === "object" && (sourceTask.type === "InputTask" || sourceTask.type === "OutputTask")) {
+        for (const toInputPortId of Object.keys(toSchema.properties || {})) {
+          if (matches.has(toInputPortId))
+            continue;
+          if (connectedInputKeys.has(toInputPortId))
+            continue;
+          matches.set(toInputPortId, toInputPortId);
+          graph.addDataflow(new Dataflow(fromTaskId, toInputPortId, toTaskId, toInputPortId));
+        }
+        return;
+      }
       if (typeof fromSchema === "boolean" || typeof toSchema === "boolean") {
         return;
       }
       for (const [toInputPortId, toPortInputSchema] of Object.entries(toSchema.properties || {})) {
         if (matches.has(toInputPortId))
           continue;
+        if (connectedInputKeys.has(toInputPortId))
+          continue;
         const candidates = [];
         for (const [fromOutputPortId, fromPortOutputSchema] of Object.entries(fromSchema.properties || {})) {
           if (comparator([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema])) {
@@ -2938,22 +3481,32 @@ class Workflow {
         graph.addDataflow(new Dataflow(fromTaskId, winner, toTaskId, toInputPortId));
       }
     };
-    makeMatch(sourceSchema, targetSchema, sourceTask.config.id, targetTask.config.id, ([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
+    makeMatch(sourceSchema, targetSchema, sourceTask.id, targetTask.id, ([fromOutputPortId, fromPortOutputSchema], [toInputPortId, toPortInputSchema]) => {
       const outputPortIdMatch = fromOutputPortId === toInputPortId;
       const outputPortIdOutputInput = fromOutputPortId === "output" && toInputPortId === "input";
       const portIdsCompatible = outputPortIdMatch || outputPortIdOutputInput;
       return portIdsCompatible && isTypeCompatible(fromPortOutputSchema, toPortInputSchema, false);
     });
-    makeMatch(sourceSchema, targetSchema, sourceTask.config.id, targetTask.config.id, ([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
+    makeMatch(sourceSchema, targetSchema, sourceTask.id, targetTask.id, ([_fromOutputPortId, fromPortOutputSchema], [_toInputPortId, toPortInputSchema]) => {
       return isTypeCompatible(fromPortOutputSchema, toPortInputSchema, true);
     });
     const requiredInputs = new Set(typeof targetSchema === "object" ? targetSchema.required || [] : []);
-    const requiredInputsNeedingConnection = [...requiredInputs].filter((r) => !providedInputKeys.has(r));
+    const requiredInputsNeedingConnection = [...requiredInputs].filter((r) => !providedInputKeys.has(r) && !connectedInputKeys.has(r));
     let unmatchedRequired = requiredInputsNeedingConnection.filter((r) => !matches.has(r));
     if (unmatchedRequired.length > 0 && earlierTasks.length > 0) {
       for (let i = 0;i < earlierTasks.length && unmatchedRequired.length > 0; i++) {
         const earlierTask = earlierTasks[i];
         const earlierOutputSchema = earlierTask.outputSchema();
+        if (earlierTask.type === "InputTask") {
+          for (const requiredInputId of [...unmatchedRequired]) {
+            if (matches.has(requiredInputId))
+              continue;
+            matches.set(requiredInputId, requiredInputId);
+            graph.addDataflow(new Dataflow(earlierTask.id, requiredInputId, targetTask.id, requiredInputId));
+          }
+          unmatchedRequired = unmatchedRequired.filter((r) => !matches.has(r));
+          continue;
+        }
         const makeMatchFromEarlier = (comparator) => {
           if (typeof earlierOutputSchema === "boolean" || typeof targetSchema === "boolean") {
             return;
@@ -2963,7 +3516,7 @@ class Workflow {
               const toPortInputSchema = targetSchema.properties?.[requiredInputId];
               if (!matches.has(requiredInputId) && toPortInputSchema && comparator([fromOutputPortId, fromPortOutputSchema], [requiredInputId, toPortInputSchema])) {
                 matches.set(requiredInputId, fromOutputPortId);
-                graph.addDataflow(new Dataflow(earlierTask.config.id, fromOutputPortId, targetTask.config.id, requiredInputId));
+                graph.addDataflow(new Dataflow(earlierTask.id, fromOutputPortId, targetTask.id, requiredInputId));
               }
             }
           }
@@ -2989,6 +3542,10 @@ class Workflow {
       };
     }
     if (matches.size === 0 && requiredInputsNeedingConnection.length === 0) {
+      const existingTargetConnections = graph.getSourceDataflows(targetTask.id);
+      if (existingTargetConnections.length > 0) {
+        return { matches, unmatchedRequired: [] };
+      }
       const hasRequiredInputs = requiredInputs.size > 0;
       const allRequiredInputsProvided = hasRequiredInputs && [...requiredInputs].every((r) => providedInputKeys.has(r));
       const hasInputsWithDefaults = typeof targetSchema === "object" && targetSchema.properties && Object.values(targetSchema.properties).some((prop) => prop && typeof prop === "object" && ("default" in prop));
@@ -3111,7 +3668,7 @@ function getLastTask(workflow) {
   return tasks.length > 0 ? tasks[tasks.length - 1] : undefined;
 }
 function connect(source, target, workflow) {
-  workflow.graph.addDataflow(new Dataflow(source.config.id, "*", target.config.id, "*"));
+  workflow.graph.addDataflow(new Dataflow(source.id, "*", target.id, "*"));
 }
 function pipe(args, workflow = new Workflow) {
   let previousTask = getLastTask(workflow);
@@ -3167,7 +3724,7 @@ var EventTaskGraphToDagMapping = {
 // src/task-graph/TaskGraph.ts
 class TaskGraphDAG extends DirectedAcyclicGraph {
   constructor() {
-    super((task) => task.config.id, (dataflow) => dataflow.id);
+    super((task) => task.id, (dataflow) => dataflow.id);
   }
 }
 
@@ -3264,18 +3821,22 @@ class TaskGraph {
     return this._dag.removeNode(taskId);
   }
   resetGraph() {
-    this.runner.resetGraph(this, uuid44());
+    this.runner.resetGraph(this, uuid45());
   }
-  toJSON() {
-    const tasks = this.getTasks().map((node) => node.toJSON());
+  toJSON(options) {
+    const tasks = this.getTasks().map((node) => node.toJSON(options));
     const dataflows = this.getDataflows().map((df) => df.toJSON());
-    return {
+    let json = {
       tasks,
       dataflows
     };
+    if (options?.withBoundaryNodes) {
+      json = addBoundaryNodesToGraphJson(json, this);
+    }
+    return json;
   }
-  toDependencyJSON() {
-    const tasks = this.getTasks().flatMap((node) => node.toDependencyJSON());
+  toDependencyJSON(options) {
+    const tasks = this.getTasks().flatMap((node) => node.toDependencyJSON(options));
     this.getDataflows().forEach((df) => {
       const target = tasks.find((node) => node.id === df.targetTaskId);
       if (!target.dependencies) {
@@ -3301,6 +3862,9 @@ class TaskGraph {
         }
       }
     });
+    if (options?.withBoundaryNodes) {
+      return addBoundaryNodesToDependencyJson(tasks, this);
+    }
     return tasks;
   }
   get events() {
@@ -3319,7 +3883,7 @@ class TaskGraph {
     const tasks = this.getTasks();
     tasks.forEach((task) => {
       const unsub = task.subscribe("status", (status) => {
-        callback(task.config.id, status);
+        callback(task.id, status);
       });
       unsubscribes.push(unsub);
     });
@@ -3328,7 +3892,7 @@ class TaskGraph {
       if (!task || typeof task.subscribe !== "function")
         return;
       const unsub = task.subscribe("status", (status) => {
-        callback(task.config.id, status);
+        callback(task.id, status);
       });
       unsubscribes.push(unsub);
     };
@@ -3343,7 +3907,7 @@ class TaskGraph {
     const tasks = this.getTasks();
     tasks.forEach((task) => {
       const unsub = task.subscribe("progress", (progress, message, ...args) => {
-        callback(task.config.id, progress, message, ...args);
+        callback(task.id, progress, message, ...args);
       });
       unsubscribes.push(unsub);
     });
@@ -3352,7 +3916,7 @@ class TaskGraph {
       if (!task || typeof task.subscribe !== "function")
         return;
       const unsub = task.subscribe("progress", (progress, message, ...args) => {
-        callback(task.config.id, progress, message, ...args);
+        callback(task.id, progress, message, ...args);
       });
       unsubscribes.push(unsub);
     };
@@ -3437,7 +4001,7 @@ class TaskGraph {
 function serialGraphEdges(tasks, inputHandle, outputHandle) {
   const edges = [];
   for (let i = 0;i < tasks.length - 1; i++) {
-    edges.push(new Dataflow(tasks[i].config.id, inputHandle, tasks[i + 1].config.id, outputHandle));
+    edges.push(new Dataflow(tasks[i].id, inputHandle, tasks[i + 1].id, outputHandle));
   }
   return edges;
 }
@@ -3447,9 +4011,206 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   graph.addDataflows(serialGraphEdges(tasks, inputHandle, outputHandle));
   return graph;
 }
+// src/task/FallbackTaskRunner.ts
+class FallbackTaskRunner extends GraphAsTaskRunner {
+  async executeTask(input) {
+    if (this.task.fallbackMode === "data") {
+      return this.executeDataFallback(input);
+    }
+    return this.executeTaskFallback(input);
+  }
+  async executeTaskReactive(input, output) {
+    const reactiveResult = await this.task.executeReactive(input, output, { own: this.own });
+    return Object.assign({}, output, reactiveResult ?? {});
+  }
+  async executeTaskFallback(input) {
+    const tasks = this.task.subGraph.getTasks();
+    if (tasks.length === 0) {
+      throw new TaskFailedError("FallbackTask has no alternatives to try");
+    }
+    const errors = [];
+    const totalAttempts = tasks.length;
+    for (let i = 0;i < tasks.length; i++) {
+      if (this.abortController?.signal.aborted) {
+        throw new TaskAbortedError("Fallback aborted");
+      }
+      const alternativeTask = tasks[i];
+      const attemptNumber = i + 1;
+      await this.handleProgress(Math.round((i + 0.5) / totalAttempts * 100), `Trying alternative ${attemptNumber}/${totalAttempts}: ${alternativeTask.type}`);
+      try {
+        this.resetTask(alternativeTask);
+        const result = await alternativeTask.run(input);
+        await this.handleProgress(100, `Alternative ${attemptNumber}/${totalAttempts} succeeded: ${alternativeTask.type}`);
+        return await this.executeTaskReactive(input, result);
+      } catch (error) {
+        if (error instanceof TaskAbortedError && !(error instanceof TaskTimeoutError)) {
+          throw error;
+        }
+        errors.push({ task: alternativeTask, error });
+      }
+    }
+    throw this.buildAggregateError(errors, "task");
+  }
+  async executeDataFallback(input) {
+    const alternatives = this.task.alternatives;
+    if (alternatives.length === 0) {
+      throw new TaskFailedError("FallbackTask has no data alternatives to try");
+    }
+    const errors = [];
+    const totalAttempts = alternatives.length;
+    for (let i = 0;i < alternatives.length; i++) {
+      if (this.abortController?.signal.aborted) {
+        throw new TaskAbortedError("Fallback aborted");
+      }
+      const alternative = alternatives[i];
+      const attemptNumber = i + 1;
+      await this.handleProgress(Math.round((i + 0.5) / totalAttempts * 100), `Trying data alternative ${attemptNumber}/${totalAttempts}`);
+      try {
+        this.resetSubgraph();
+        const mergedInput = { ...input, ...alternative };
+        const results = await this.task.subGraph.run(mergedInput, {
+          parentSignal: this.abortController?.signal,
+          outputCache: this.outputCache
+        });
+        const mergedOutput = this.task.subGraph.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
+        await this.handleProgress(100, `Data alternative ${attemptNumber}/${totalAttempts} succeeded`);
+        return await this.executeTaskReactive(input, mergedOutput);
+      } catch (error) {
+        if (error instanceof TaskAbortedError && !(error instanceof TaskTimeoutError)) {
+          throw error;
+        }
+        errors.push({ alternative, error });
+      }
+    }
+    throw this.buildAggregateError(errors, "data");
+  }
+  resetTask(task) {
+    task.status = TaskStatus.PENDING;
+    task.progress = 0;
+    task.error = undefined;
+    task.completedAt = undefined;
+    task.startedAt = undefined;
+    task.resetInputData();
+  }
+  resetSubgraph() {
+    for (const task of this.task.subGraph.getTasks()) {
+      this.resetTask(task);
+    }
+    for (const dataflow of this.task.subGraph.getDataflows()) {
+      dataflow.reset();
+    }
+  }
+  buildAggregateError(errors, mode) {
+    const label = mode === "task" ? "alternative" : "data alternative";
+    const details = errors.map((e, i) => {
+      const prefix = e.error instanceof TaskTimeoutError ? "[timeout] " : "";
+      return `  ${label} ${i + 1}: ${prefix}${e.error.message}`;
+    }).join(`
+`);
+    return new TaskFailedError(`All ${errors.length} ${label}s failed:
+${details}`);
+  }
+}
+
+// src/task/FallbackTask.ts
+var fallbackTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...graphAsTaskConfigSchema["properties"],
+    fallbackMode: { type: "string", enum: ["task", "data"] },
+    alternatives: { type: "array", items: { type: "object", additionalProperties: true } }
+  },
+  additionalProperties: false
+};
+
+class FallbackTask extends GraphAsTask {
+  static type = "FallbackTask";
+  static category = "Flow Control";
+  static title = "Fallback";
+  static description = "Try alternatives until one succeeds";
+  static hasDynamicSchemas = true;
+  static configSchema() {
+    return fallbackTaskConfigSchema;
+  }
+  get runner() {
+    if (!this._runner) {
+      this._runner = new FallbackTaskRunner(this);
+    }
+    return this._runner;
+  }
+  get fallbackMode() {
+    return this.config?.fallbackMode ?? "task";
+  }
+  get alternatives() {
+    return this.config?.alternatives ?? [];
+  }
+  inputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.inputSchema();
+    }
+    if (this.fallbackMode === "data") {
+      return super.inputSchema();
+    }
+    const properties = {};
+    const tasks = this.subGraph.getTasks();
+    for (const task of tasks) {
+      const taskInputSchema = task.inputSchema();
+      if (typeof taskInputSchema === "boolean")
+        continue;
+      const taskProperties = taskInputSchema.properties || {};
+      for (const [inputName, inputProp] of Object.entries(taskProperties)) {
+        if (!properties[inputName]) {
+          properties[inputName] = inputProp;
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: true
+    };
+  }
+  outputSchema() {
+    if (!this.hasChildren()) {
+      return this.constructor.outputSchema();
+    }
+    const tasks = this.subGraph.getTasks();
+    if (tasks.length === 0) {
+      return { type: "object", properties: {}, additionalProperties: false };
+    }
+    if (this.fallbackMode === "task") {
+      const firstTask = tasks[0];
+      return firstTask.outputSchema();
+    }
+    return super.outputSchema();
+  }
+  toJSON() {
+    const json = super.toJSON();
+    return {
+      ...json,
+      config: {
+        ..."config" in json ? json.config : {},
+        fallbackMode: this.fallbackMode,
+        ...this.alternatives.length > 0 ? { alternatives: this.alternatives } : {}
+      }
+    };
+  }
+}
+queueMicrotask(() => {
+  Workflow.prototype.fallback = function() {
+    return this.addLoopTask(FallbackTask, { fallbackMode: "task" });
+  };
+  Workflow.prototype.endFallback = CreateEndLoopWorkflow("endFallback");
+  Workflow.prototype.fallbackWith = function(alternatives) {
+    return this.addLoopTask(FallbackTask, {
+      fallbackMode: "data",
+      alternatives
+    });
+  };
+  Workflow.prototype.endFallbackWith = CreateEndLoopWorkflow("endFallbackWith");
+});
 // src/task/IteratorTaskRunner.ts
 class IteratorTaskRunner extends GraphAsTaskRunner {
-  subGraphRunChain = Promise.resolve();
   async executeTask(input) {
     const analysis = this.task.analyzeIterationInput(input);
     if (analysis.iterationCount === 0) {
@@ -3471,13 +4232,18 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const concurrency = Math.max(1, Math.min(requestedConcurrency, iterationCount));
     const orderedResults = preserveOrder ? new Array(iterationCount) : [];
     const completionOrderResults = [];
+    let completedCount = 0;
     for (let batchStart = 0;batchStart < iterationCount; batchStart += batchSize) {
       if (this.abortController?.signal.aborted) {
         break;
       }
       const batchEnd = Math.min(batchStart + batchSize, iterationCount);
       const batchIndices = Array.from({ length: batchEnd - batchStart }, (_, i) => batchStart + i);
-      const batchResults = await this.executeBatch(batchIndices, analysis, iterationCount, concurrency);
+      const batchResults = await this.executeBatch(batchIndices, analysis, iterationCount, concurrency, async () => {
+        completedCount++;
+        const progress = Math.round(completedCount / iterationCount * 100);
+        await this.handleProgress(progress, `Completed ${completedCount}/${iterationCount} iterations`);
+      });
       for (const { index, result } of batchResults) {
         if (result === undefined)
           continue;
@@ -3487,8 +4253,6 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
           completionOrderResults.push(result);
         }
       }
-      const progress = Math.round(batchEnd / iterationCount * 100);
-      await this.handleProgress(progress, `Completed ${batchEnd}/${iterationCount} iterations`);
     }
     const collected = preserveOrder ? orderedResults.filter((result) => result !== undefined) : completionOrderResults;
     return this.task.collectResults(collected);
@@ -3510,7 +4274,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     }
     return accumulator;
   }
-  async executeBatch(indices, analysis, iterationCount, concurrency) {
+  async executeBatch(indices, analysis, iterationCount, concurrency, onItemComplete) {
     const results = [];
     let cursor = 0;
     const workerCount = Math.max(1, Math.min(concurrency, indices.length));
@@ -3528,33 +4292,40 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
         const iterationInput = this.task.buildIterationRunInput(analysis, index, iterationCount);
         const result = await this.executeSubgraphIteration(iterationInput);
         results.push({ index, result });
+        await onItemComplete?.();
       }
     });
     await Promise.all(workers);
     return results;
   }
+  cloneGraph(graph) {
+    const clone = new TaskGraph;
+    for (const task of graph.getTasks()) {
+      const ctor = task.constructor;
+      const newTask = new ctor(task.defaults, task.config);
+      if (task.hasChildren()) {
+        newTask.subGraph = this.cloneGraph(task.subGraph);
+      }
+      clone.addTask(newTask);
+    }
+    for (const df of graph.getDataflows()) {
+      clone.addDataflow(new Dataflow(df.sourceTaskId, df.sourceTaskPortId, df.targetTaskId, df.targetTaskPortId));
+    }
+    return clone;
+  }
   async executeSubgraphIteration(input) {
-    let releaseTurn;
-    const waitForPreviousRun = this.subGraphRunChain;
-    this.subGraphRunChain = new Promise((resolve) => {
-      releaseTurn = resolve;
+    if (this.abortController?.signal.aborted) {
+      return;
+    }
+    const graphClone = this.cloneGraph(this.task.subGraph);
+    const results = await graphClone.run(input, {
+      parentSignal: this.abortController?.signal,
+      outputCache: this.outputCache
     });
-    await waitForPreviousRun;
-    try {
-      if (this.abortController?.signal.aborted) {
-        return;
-      }
-      const results = await this.task.subGraph.run(input, {
-        parentSignal: this.abortController?.signal,
-        outputCache: this.outputCache
-      });
-      if (results.length === 0) {
-        return;
-      }
-      return this.task.subGraph.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
-    } finally {
-      releaseTurn?.();
+    if (results.length === 0) {
+      return;
     }
+    return graphClone.mergeExecuteOutputsToRunOutput(results, this.task.compoundMerge);
   }
 }
 
@@ -3635,23 +4406,17 @@ function inferIterationFromSchema(schema) {
   return false;
 }
 function createFlexibleSchema(baseSchema) {
-  if (typeof baseSchema === "boolean")
-    return baseSchema;
   return {
     anyOf: [baseSchema, { type: "array", items: baseSchema }]
   };
 }
 function createArraySchema(baseSchema) {
-  if (typeof baseSchema === "boolean")
-    return baseSchema;
   return {
     type: "array",
     items: baseSchema
   };
 }
 function extractBaseSchema(schema) {
-  if (typeof schema === "boolean")
-    return schema;
   const schemaType = schema.type;
   if (schemaType === "array" && schema.items) {
     return schema.items;
@@ -3844,7 +4609,7 @@ class IteratorTask extends GraphAsTask {
     const tasks = this.subGraph.getTasks();
     if (tasks.length === 0)
       return;
-    const startingNodes = tasks.filter((task) => this.subGraph.getSourceDataflows(task.config.id).length === 0);
+    const startingNodes = tasks.filter((task) => this.subGraph.getSourceDataflows(task.id).length === 0);
     const sources = startingNodes.length > 0 ? startingNodes : tasks;
     const properties = {};
     const required = [];
@@ -3871,6 +4636,33 @@ class IteratorTask extends GraphAsTask {
         }
       }
     }
+    const sourceIds = new Set(sources.map((t) => t.id));
+    for (const task of tasks) {
+      if (sourceIds.has(task.id))
+        continue;
+      const inputSchema = task.inputSchema();
+      if (typeof inputSchema === "boolean")
+        continue;
+      const requiredKeys = new Set(inputSchema.required || []);
+      if (requiredKeys.size === 0)
+        continue;
+      const connectedPorts = new Set(this.subGraph.getSourceDataflows(task.id).map((df) => df.targetTaskPortId));
+      for (const key of requiredKeys) {
+        if (connectedPorts.has(key))
+          continue;
+        if (properties[key])
+          continue;
+        if (task.defaults && task.defaults[key] !== undefined)
+          continue;
+        const prop = (inputSchema.properties || {})[key];
+        if (!prop || typeof prop === "boolean")
+          continue;
+        properties[key] = prop;
+        if (!required.includes(key)) {
+          required.push(key);
+        }
+      }
+    }
     return {
       type: "object",
       properties,
@@ -4005,7 +4797,7 @@ class IteratorTask extends GraphAsTask {
     if (!this.hasChildren()) {
       return { type: "object", properties: {}, additionalProperties: false };
     }
-    const endingNodes = this.subGraph.getTasks().filter((task) => this.subGraph.getTargetDataflows(task.config.id).length === 0);
+    const endingNodes = this.subGraph.getTasks().filter((task) => this.subGraph.getTargetDataflows(task.id).length === 0);
     if (endingNodes.length === 0) {
       return { type: "object", properties: {}, additionalProperties: false };
     }
@@ -4215,8 +5007,8 @@ class WhileTask extends GraphAsTask {
         currentInput = { ...currentInput, ...currentOutput };
       }
       this._currentIteration++;
-      const progress = Math.min(this._currentIteration / effectiveMax * 100, 99);
-      await context.updateProgress(progress, `Iteration ${this._currentIteration}`);
+      const progress = Math.min(Math.round(this._currentIteration / effectiveMax * 100), 99);
+      await context.updateProgress(progress, `Completed ${this._currentIteration}/${effectiveMax} iterations`);
     }
     return currentOutput;
   }
@@ -4259,8 +5051,8 @@ class WhileTask extends GraphAsTask {
         currentInput = { ...currentInput, ...currentOutput };
       }
       this._currentIteration++;
-      const progress = Math.min(this._currentIteration / effectiveMax * 100, 99);
-      await context.updateProgress(progress, `Iteration ${this._currentIteration}`);
+      const progress = Math.min(Math.round(this._currentIteration / effectiveMax * 100), 99);
+      await context.updateProgress(progress, `Completed ${this._currentIteration}/${effectiveMax} iterations`);
     }
     yield { type: "finish", data: currentOutput };
   }
@@ -4336,7 +5128,7 @@ class WhileTask extends GraphAsTask {
       return this.constructor.outputSchema();
     }
     const tasks = this.subGraph.getTasks();
-    const endingNodes = tasks.filter((task) => this.subGraph.getTargetDataflows(task.config.id).length === 0);
+    const endingNodes = tasks.filter((task) => this.subGraph.getTargetDataflows(task.id).length === 0);
     if (endingNodes.length === 0) {
       return this.constructor.outputSchema();
     }
@@ -4711,7 +5503,11 @@ var jobQueueTaskConfigSchema = {
   type: "object",
   properties: {
     ...graphAsTaskConfigSchema["properties"],
-    queue: {}
+    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
 };
@@ -4999,7 +5795,7 @@ class ReduceTask extends IteratorTask {
     if (!this.hasChildren()) {
       return this.constructor.outputSchema();
     }
-    const endingNodes = this.subGraph.getTasks().filter((task) => this.subGraph.getTargetDataflows(task.config.id).length === 0);
+    const endingNodes = this.subGraph.getTasks().filter((task) => this.subGraph.getTargetDataflows(task.id).length === 0);
     if (endingNodes.length === 0) {
       return this.constructor.outputSchema();
     }
@@ -5037,14 +5833,14 @@ var TaskRegistry = {
 };
 
 // src/task/TaskJSON.ts
-var createSingleTaskFromJSON = (item) => {
+var createSingleTaskFromJSON = (item, taskRegistry) => {
   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");
-  const taskClass = TaskRegistry.all.get(item.type);
+  const taskClass = taskRegistry?.get(item.type) ?? TaskRegistry.all.get(item.type);
   if (!taskClass)
     throw new TaskJSONError(`Task type ${item.type} not found, perhaps not registered?`);
   const taskConfig = {
@@ -5071,20 +5867,20 @@ var createGraphFromDependencyJSON = (jsonItems) => {
   }
   return subGraph;
 };
-var createTaskFromGraphJSON = (item) => {
-  const task = createSingleTaskFromJSON(item);
+var createTaskFromGraphJSON = (item, taskRegistry) => {
+  const task = createSingleTaskFromJSON(item, taskRegistry);
   if (item.subgraph) {
     if (!(task instanceof GraphAsTask)) {
       throw new TaskConfigurationError("Subgraph is only supported for GraphAsTask");
     }
-    task.subGraph = createGraphFromGraphJSON(item.subgraph);
+    task.subGraph = createGraphFromGraphJSON(item.subgraph, taskRegistry);
   }
   return task;
 };
-var createGraphFromGraphJSON = (graphJsonObj) => {
+var createGraphFromGraphJSON = (graphJsonObj, taskRegistry) => {
   const subGraph = new TaskGraph;
   for (const subitem of graphJsonObj.tasks) {
-    subGraph.addTask(createTaskFromGraphJSON(subitem));
+    subGraph.addTask(createTaskFromGraphJSON(subitem, taskRegistry));
   }
   for (const subitem of graphJsonObj.dataflows) {
     subGraph.addDataflow(new Dataflow(subitem.sourceTaskId, subitem.sourceTaskPortId, subitem.targetTaskId, subitem.targetTaskPortId));
@@ -5093,7 +5889,7 @@ var createGraphFromGraphJSON = (graphJsonObj) => {
 };
 // src/task/index.ts
 var registerBaseTasks = () => {
-  const tasks = [GraphAsTask, ConditionalTask, MapTask, WhileTask, ReduceTask];
+  const tasks = [GraphAsTask, ConditionalTask, FallbackTask, MapTask, WhileTask, ReduceTask];
   tasks.map(TaskRegistry.registerTask);
   return tasks;
 };
@@ -5276,11 +6072,14 @@ export {
   isFlexibleSchema,
   hasVectorOutput,
   hasVectorLikeInput,
+  hasStructuredOutput,
   graphAsTaskConfigSchema,
   getTaskQueueRegistry,
+  getStructuredOutputSchemas,
   getStreamingPorts,
   getPortStreamMode,
   getOutputStreamMode,
+  getObjectPortId,
   getNestedValue,
   getLastTask,
   getJobQueueFactory,
@@ -5289,6 +6088,7 @@ export {
   getAppendPortId,
   findArrayPorts,
   filterIterationProperties,
+  fallbackTaskConfigSchema,
   extractIterationProperties,
   extractBaseSchema,
   evaluateCondition,
@@ -5303,13 +6103,19 @@ export {
   createArraySchema,
   connect,
   conditionalTaskConfigSchema,
+  computeGraphOutputSchema,
+  computeGraphInputSchema,
+  calculateNodeDepths,
   buildIterationInputSchema,
   addIterationContextToSchema,
+  addBoundaryNodesToGraphJson,
+  addBoundaryNodesToDependencyJson,
   WorkflowError,
   Workflow,
   WhileTaskRunner,
   WhileTask,
   WHILE_CONTEXT_SCHEMA,
+  TaskTimeoutError,
   TaskStatus,
   TaskRegistry,
   TaskQueueRegistry,
@@ -5345,6 +6151,8 @@ export {
   GraphAsTaskRunner,
   GraphAsTask,
   GRAPH_RESULT_ARRAY,
+  FallbackTaskRunner,
+  FallbackTask,
   EventTaskGraphToDagMapping,
   EventDagToTaskGraphMapping,
   DataflowArrow,
@@ -5358,4 +6166,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=75D3D24E4274E79564756E2164756E21
+//# debugId=2492C1E27B2BED5064756E2164756E21