@workglow/task-graph 0.0.99 → 0.0.101

package/dist/browser.js

@@ -11,6 +11,22 @@ var TaskStatus = {
   ABORTING: "ABORTING",
   FAILED: "FAILED"
 };
+var TaskConfigSchema = {
+  type: "object",
+  properties: {
+    id: {},
+    title: { type: "string" },
+    description: { type: "string" },
+    cacheable: { type: "boolean" },
+    inputSchema: { type: "object", properties: {}, additionalProperties: true },
+    outputSchema: { type: "object", properties: {}, additionalProperties: true },
+    extras: {
+      type: "object",
+      additionalProperties: true
+    }
+  },
+  additionalProperties: false
+};
 
 // src/task-graph/Dataflow.ts
 var DATAFLOW_ALL_PORTS = "*";
@@ -47,10 +63,8 @@ class Dataflow {
     if (!this.stream)
       return;
     const reader = this.stream.getReader();
-    const accumulatedPorts = new Map;
     let lastSnapshotData = undefined;
     let finishData = undefined;
-    let hasTextDelta = false;
     let streamError;
     try {
       while (true) {
@@ -58,16 +72,6 @@ class Dataflow {
         if (done)
           break;
         switch (event.type) {
-          case "text-delta": {
-            if (this.sourceTaskPortId !== DATAFLOW_ALL_PORTS && event.port !== this.sourceTaskPortId) {
-              break;
-            }
-            hasTextDelta = true;
-            accumulatedPorts.set(event.port, (accumulatedPorts.get(event.port) ?? "") + event.textDelta);
-            break;
-          }
-          case "object-delta":
-            break;
           case "snapshot":
             lastSnapshotData = event.data;
             break;
@@ -90,19 +94,8 @@ class Dataflow {
     }
     if (lastSnapshotData !== undefined) {
       this.setPortData(lastSnapshotData);
-    } else if (finishData && Object.keys(finishData).length > 0) {
+    } else if (finishData !== undefined) {
       this.setPortData(finishData);
-    } else if (hasTextDelta) {
-      if (this.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
-        const obj = {};
-        for (const [port, text] of accumulatedPorts) {
-          obj[port] = text;
-        }
-        this.value = obj;
-      } else {
-        const text = accumulatedPorts.values().next().value ?? "";
-        this.value = text;
-      }
     }
   }
   reset() {
@@ -548,6 +541,7 @@ class TaskRunner {
   outputCache;
   registry = globalServiceRegistry;
   inputStreams;
+  shouldAccumulate = true;
   constructor(task) {
     this.task = task;
     this.own = this.own.bind(this);
@@ -656,7 +650,7 @@ class TaskRunner {
         throw new TaskError(`Task ${this.task.type} declares append streaming but no output port has x-stream: "append"`);
       }
     }
-    const accumulated = new Map;
+    const accumulated = this.shouldAccumulate ? new Map : undefined;
     let chunkCount = 0;
     let finalOutput;
     this.task.emit("stream_start");
@@ -676,33 +670,40 @@ class TaskRunner {
       if (event.type === "snapshot") {
         this.task.runOutputData = event.data;
       }
-      this.task.emit("stream_chunk", event);
       switch (event.type) {
         case "text-delta": {
-          accumulated.set(event.port, (accumulated.get(event.port) ?? "") + event.textDelta);
+          if (accumulated) {
+            accumulated.set(event.port, (accumulated.get(event.port) ?? "") + event.textDelta);
+          }
+          this.task.emit("stream_chunk", event);
           const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
           await this.handleProgress(progress);
           break;
         }
         case "object-delta": {
+          this.task.emit("stream_chunk", event);
           const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
           await this.handleProgress(progress);
           break;
         }
         case "snapshot": {
+          this.task.emit("stream_chunk", event);
           const progress = Math.min(99, Math.round(100 * (1 - Math.exp(-0.05 * chunkCount))));
           await this.handleProgress(progress);
           break;
         }
         case "finish": {
-          if (streamMode === "append") {
+          if (accumulated) {
             const merged = { ...event.data || {} };
             for (const [port, text] of accumulated) {
-              merged[port] = text.length > 0 ? text : event.data?.[port] ?? "";
+              if (text.length > 0)
+                merged[port] = text;
             }
             finalOutput = merged;
-          } else if (streamMode === "replace") {
+            this.task.emit("stream_chunk", { type: "finish", data: merged });
+          } else {
             finalOutput = event.data;
+            this.task.emit("stream_chunk", event);
           }
           break;
         }
@@ -732,7 +733,7 @@ class TaskRunner {
     this.abortController.signal.addEventListener("abort", () => {
       this.handleAbort();
     });
-    const cache = this.task.config.outputCache ?? config.outputCache;
+    const cache = config.outputCache ?? this.task.runConfig?.outputCache;
     if (cache === true) {
       let instance = globalServiceRegistry.get(TASK_OUTPUT_REPOSITORY);
       this.outputCache = instance;
@@ -741,6 +742,7 @@ class TaskRunner {
     } else if (cache instanceof TaskOutputRepository) {
       this.outputCache = cache;
     }
+    this.shouldAccumulate = config.shouldAccumulate !== false;
     if (config.updateProgress) {
       this.updateProgress = config.updateProgress;
     }
@@ -823,8 +825,10 @@ class Task {
   static type = "Task";
   static category = "Hidden";
   static title = "";
+  static description = "";
   static cacheable = true;
   static hasDynamicSchemas = false;
+  static passthroughInputsToOutputs = false;
   static inputSchema() {
     return {
       type: "object",
@@ -839,6 +843,9 @@ class Task {
       additionalProperties: false
     };
   }
+  static configSchema() {
+    return TaskConfigSchema;
+  }
   async execute(_input, context) {
     if (context.signal?.aborted) {
       throw new TaskAbortedError("Task aborted");
@@ -855,8 +862,8 @@ class Task {
     }
     return this._runner;
   }
-  async run(overrides = {}) {
-    return this.runner.run(overrides);
+  async run(overrides = {}, runConfig = {}) {
+    return this.runner.run(overrides, { ...this.runConfig, ...runConfig });
   }
   async runReactive(overrides = {}) {
     return this.runner.runReactive(overrides);
@@ -873,6 +880,9 @@ class Task {
   outputSchema() {
     return this.constructor.outputSchema();
   }
+  configSchema() {
+    return this.constructor.configSchema();
+  }
   get type() {
     return this.constructor.type;
   }
@@ -880,15 +890,19 @@ class Task {
     return this.constructor.category;
   }
   get title() {
-    return this.constructor.title;
+    return this.config?.title ?? this.constructor.title;
+  }
+  get description() {
+    return this.config?.description ?? this.constructor.description;
   }
   get cacheable() {
-    return this.config?.cacheable ?? this.constructor.cacheable;
+    return this.runConfig?.cacheable ?? this.config?.cacheable ?? this.constructor.cacheable;
   }
   defaults;
   runInputData = {};
   runOutputData = {};
   config;
+  runConfig = {};
   status = TaskStatus.PENDING;
   progress = 0;
   createdAt = new Date;
@@ -902,16 +916,18 @@ class Task {
     return this._events;
   }
   _events;
-  constructor(callerDefaultInputs = {}, config = {}) {
+  constructor(callerDefaultInputs = {}, config = {}, runConfig = {}) {
     const inputDefaults = this.getDefaultInputsFromStaticInputDefinitions();
     const mergedDefaults = Object.assign(inputDefaults, callerDefaultInputs);
     this.defaults = this.stripSymbols(mergedDefaults);
     this.resetInputData();
-    const name = this.title || new.target.title || new.target.name;
-    this.config = Object.assign({
+    const title = this.constructor.title || undefined;
+    const baseConfig = Object.assign({
       id: uuid4(),
-      name
+      ...title ? { title } : {}
     }, config);
+    this.config = this.validateAndApplyConfigDefaults(baseConfig);
+    this.runConfig = runConfig;
   }
   getDefaultInputsFromStaticInputDefinitions() {
     const schema = this.inputSchema();
@@ -948,7 +964,7 @@ class Task {
       return obj;
     }
     if (visited.has(obj)) {
-      throw new Error("Circular reference detected in input data. " + "Cannot clone objects with circular references.");
+      throw new TaskConfigurationError("Circular reference detected in input data. " + "Cannot clone objects with circular references.");
     }
     if (ArrayBuffer.isView(obj)) {
       if (typeof DataView !== "undefined" && obj instanceof DataView) {
@@ -1093,6 +1109,37 @@ class Task {
     const finalOutputSchema = outputSchema ?? this.outputSchema();
     this.emit("schemaChange", finalInputSchema, finalOutputSchema);
   }
+  static _configSchemaNode = new Map;
+  static getConfigSchemaNode(type) {
+    const schema = this.configSchema();
+    if (!schema)
+      return;
+    if (!this._configSchemaNode.has(type)) {
+      try {
+        const schemaNode = typeof schema === "boolean" ? compileSchema(schema ? {} : { not: {} }) : compileSchema(schema);
+        this._configSchemaNode.set(type, schemaNode);
+      } catch (error) {
+        console.warn(`Failed to compile config schema for ${this.type}:`, error);
+        return;
+      }
+    }
+    return this._configSchemaNode.get(type);
+  }
+  validateAndApplyConfigDefaults(config) {
+    const ctor = this.constructor;
+    const schemaNode = ctor.getConfigSchemaNode(this.type);
+    if (!schemaNode)
+      return config;
+    const result = schemaNode.validate(config);
+    if (!result.valid) {
+      const errorMessages = result.errors.map((e) => {
+        const path = e.data?.pointer || "";
+        return `${e.message}${path ? ` (${path})` : ""}`;
+      });
+      throw new TaskConfigurationError(`[${ctor.name}] Configuration Error: ${errorMessages.join(", ")}`);
+    }
+    return config;
+  }
   static _inputSchemaNode = new Map;
   static generateInputSchemaNode(schema) {
     if (typeof schema === "boolean") {
@@ -1157,12 +1204,16 @@ class Task {
   }
   toJSON() {
     const extras = this.config.extras;
-    let json = this.stripSymbols({
+    const json = this.stripSymbols({
       id: this.config.id,
       type: this.type,
-      ...this.config.name ? { name: this.config.name } : {},
       defaults: this.defaults,
-      ...extras && Object.keys(extras).length ? { extras } : {}
+      config: {
+        ...this.config.title ? { title: this.config.title } : {},
+        ...this.config.inputSchema ? { inputSchema: this.config.inputSchema } : {},
+        ...this.config.outputSchema ? { outputSchema: this.config.outputSchema } : {},
+        ...extras && Object.keys(extras).length ? { extras } : {}
+      }
     });
     return json;
   }
@@ -1205,12 +1256,27 @@ class Task {
 }
 
 // src/task/ConditionalTask.ts
+var conditionalTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema["properties"],
+    branches: { type: "array", items: {} },
+    defaultBranch: { type: "string" },
+    exclusive: { type: "boolean" },
+    conditionConfig: { type: "object", additionalProperties: true }
+  },
+  additionalProperties: false
+};
+
 class ConditionalTask extends Task {
   static type = "ConditionalTask";
   static category = "Flow Control";
   static title = "Condition";
   static description = "Route data based on conditions";
   static hasDynamicSchemas = true;
+  static configSchema() {
+    return conditionalTaskConfigSchema;
+  }
   activeBranches = new Set;
   buildBranchesFromConditionConfig(conditionConfig) {
     if (!conditionConfig?.branches || conditionConfig.branches.length === 0) {
@@ -1241,7 +1307,7 @@ class ConditionalTask extends Task {
         fromConditionConfig: false
       };
     }
-    const conditionConfig = input.conditionConfig ?? this.config.extras?.conditionConfig;
+    const conditionConfig = input.conditionConfig ?? this.config.conditionConfig;
     if (conditionConfig) {
       return {
         branches: this.buildBranchesFromConditionConfig(conditionConfig),
@@ -1552,6 +1618,7 @@ class TaskGraphRunner {
   reactiveRunning = false;
   graph;
   outputCache;
+  accumulateLeafOutputs = true;
   registry = globalServiceRegistry2;
   abortController;
   inProgressTasks = new Map;
@@ -1771,6 +1838,29 @@ class TaskGraphRunner {
       }
     }
   }
+  taskNeedsAccumulation(task) {
+    if (this.outputCache)
+      return true;
+    const outEdges = this.graph.getTargetDataflows(task.config.id);
+    if (outEdges.length === 0)
+      return this.accumulateLeafOutputs;
+    const outSchema = task.outputSchema();
+    for (const df of outEdges) {
+      if (df.sourceTaskPortId === DATAFLOW_ALL_PORTS) {
+        if (getStreamingPorts(outSchema).length > 0)
+          return true;
+        continue;
+      }
+      const targetTask = this.graph.getTask(df.targetTaskId);
+      if (!targetTask)
+        continue;
+      const inSchema = targetTask.inputSchema();
+      if (edgeNeedsAccumulation(outSchema, df.sourceTaskPortId, inSchema, df.targetTaskPortId)) {
+        return true;
+      }
+    }
+    return false;
+  }
   async runTask(task, input) {
     const isStreamable = isTaskStreamable(task);
     if (isStreamable) {
@@ -1793,7 +1883,7 @@ class TaskGraphRunner {
       return this.runStreamingTask(task, input);
     }
     const results = await task.runner.run(input, {
-      outputCache: this.outputCache,
+      outputCache: this.outputCache ?? false,
       updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
       registry: this.registry
     });
@@ -1813,6 +1903,7 @@ class TaskGraphRunner {
   }
   async runStreamingTask(task, input) {
     const streamMode = getOutputStreamMode(task.outputSchema());
+    const shouldAccumulate = this.taskNeedsAccumulation(task);
     let streamingNotified = false;
     const onStatus = (status) => {
       if (status === TaskStatus.STREAMING && !streamingNotified) {
@@ -1837,7 +1928,8 @@ class TaskGraphRunner {
     task.on("stream_end", onStreamEnd);
     try {
       const results = await task.runner.run(input, {
-        outputCache: this.outputCache,
+        outputCache: this.outputCache ?? false,
+        shouldAccumulate,
         updateProgress: async (task2, progress, message, ...args) => await this.handleProgress(task2, progress, message, ...args),
         registry: this.registry
       });
@@ -1919,9 +2011,7 @@ class TaskGraphRunner {
     task.runOutputData = {};
     task.error = undefined;
     task.progress = 0;
-    if (task.config) {
-      task.config.runnerId = runId;
-    }
+    task.runConfig = { ...task.runConfig, runnerId: runId };
     this.pushStatusFromNodeToEdges(graph, task);
     this.pushErrorFromNodeToEdges(graph, task);
     task.emit("reset");
@@ -1945,6 +2035,7 @@ class TaskGraphRunner {
     } else {
       this.registry = new ServiceRegistry2(globalServiceRegistry2.container.createChildContainer());
     }
+    this.accumulateLeafOutputs = config?.accumulateLeafOutputs !== false;
     if (config?.outputCache !== undefined) {
       if (typeof config.outputCache === "boolean") {
         if (config.outputCache === true) {
@@ -2084,6 +2175,15 @@ class GraphAsTaskRunner extends TaskRunner {
 }
 
 // src/task/GraphAsTask.ts
+var graphAsTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema["properties"],
+    compoundMerge: { type: "string" }
+  },
+  additionalProperties: false
+};
+
 class GraphAsTask extends Task {
   static type = "GraphAsTask";
   static title = "Group";
@@ -2105,11 +2205,14 @@ class GraphAsTask extends Task {
     }
     return this._runner;
   }
+  static configSchema() {
+    return graphAsTaskConfigSchema;
+  }
   get compoundMerge() {
     return this.config?.compoundMerge || this.constructor.compoundMerge;
   }
   get cacheable() {
-    return this.config?.cacheable ?? (this.constructor.cacheable && !this.hasChildren());
+    return this.runConfig?.cacheable ?? this.config?.cacheable ?? (this.constructor.cacheable && !this.hasChildren());
   }
   inputSchema() {
     if (!this.hasChildren()) {
@@ -2276,7 +2379,7 @@ class GraphAsTask extends Task {
           }
         }
       });
-      const runPromise = this.subGraph.run(input, { parentSignal: context.signal }).then((results2) => {
+      const runPromise = this.subGraph.run(input, { parentSignal: context.signal, accumulateLeafOutputs: false }).then((results2) => {
         subgraphDone = true;
         resolveWaiting?.();
         return results2;
@@ -2986,17 +3089,19 @@ function ensureTask(arg, config = {}) {
     return arg;
   }
   if (arg instanceof TaskGraph) {
-    if (config.isOwned) {
-      return new OwnGraphTask({}, { ...config, subGraph: arg });
+    const { isOwned, ...cleanConfig } = config;
+    if (isOwned) {
+      return new OwnGraphTask({}, { ...cleanConfig, subGraph: arg });
     } else {
-      return new GraphTask({}, { ...config, subGraph: arg });
+      return new GraphTask({}, { ...cleanConfig, subGraph: arg });
     }
   }
   if (arg instanceof Workflow) {
-    if (config.isOwned) {
-      return new OwnWorkflowTask({}, { ...config, subGraph: arg.graph });
+    const { isOwned, ...cleanConfig } = config;
+    if (isOwned) {
+      return new OwnWorkflowTask({}, { ...cleanConfig, subGraph: arg.graph });
     } else {
-      return new WorkflowTask2({}, { ...config, subGraph: arg.graph });
+      return new WorkflowTask2({}, { ...cleanConfig, subGraph: arg.graph });
     }
   }
   return convertPipeFunctionToTask(arg, config);
@@ -3083,7 +3188,8 @@ class TaskGraph {
   run(input = {}, config = {}) {
     return this.runner.runGraph(input, {
       outputCache: config?.outputCache || this.outputCache,
-      parentSignal: config?.parentSignal || undefined
+      parentSignal: config?.parentSignal || undefined,
+      accumulateLeafOutputs: config?.accumulateLeafOutputs
     });
   }
   runReactive(input = {}) {
@@ -3472,6 +3578,16 @@ var ITERATOR_CONTEXT_SCHEMA = {
     }
   }
 };
+var iteratorTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...graphAsTaskConfigSchema["properties"],
+    concurrencyLimit: { type: "integer", minimum: 1 },
+    batchSize: { type: "integer", minimum: 1 },
+    iterationInputConfig: { type: "object", additionalProperties: true }
+  },
+  additionalProperties: false
+};
 function isArrayVariant(schema) {
   if (!schema || typeof schema !== "object")
     return false;
@@ -3580,6 +3696,9 @@ class IteratorTask extends GraphAsTask {
   static title = "Iterator";
   static description = "Base class for loop-type tasks";
   static hasDynamicSchemas = true;
+  static configSchema() {
+    return iteratorTaskConfigSchema;
+  }
   static getIterationContextSchema() {
     return ITERATOR_CONTEXT_SCHEMA;
   }
@@ -3940,6 +4059,20 @@ var WHILE_CONTEXT_SCHEMA = {
     }
   }
 };
+var whileTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...graphAsTaskConfigSchema["properties"],
+    condition: {},
+    maxIterations: { type: "integer", minimum: 1 },
+    chainIterations: { type: "boolean" },
+    conditionField: { type: "string" },
+    conditionOperator: { type: "string" },
+    conditionValue: { type: "string" },
+    iterationInputConfig: { type: "object", additionalProperties: true }
+  },
+  additionalProperties: false
+};
 
 class WhileTask extends GraphAsTask {
   static type = "WhileTask";
@@ -3947,6 +4080,9 @@ class WhileTask extends GraphAsTask {
   static title = "While Loop";
   static description = "Loops until a condition function returns false";
   static hasDynamicSchemas = true;
+  static configSchema() {
+    return whileTaskConfigSchema;
+  }
   static getIterationContextSchema() {
     return WHILE_CONTEXT_SCHEMA;
   }
@@ -3964,38 +4100,30 @@ class WhileTask extends GraphAsTask {
     return this.config.condition;
   }
   get maxIterations() {
-    if (this.config.maxIterations !== undefined)
-      return this.config.maxIterations;
-    const wc = this.config.extras?.whileConfig;
-    return wc?.maxIterations ?? 100;
+    return this.config.maxIterations ?? 100;
   }
   get chainIterations() {
-    if (this.config.chainIterations !== undefined)
-      return this.config.chainIterations;
-    const wc = this.config.extras?.whileConfig;
-    return wc?.chainIterations ?? true;
+    return this.config.chainIterations ?? true;
   }
   get currentIteration() {
     return this._currentIteration;
   }
-  buildConditionFromExtras() {
-    const wc = this.config.extras?.whileConfig;
-    if (!wc?.conditionOperator) {
+  buildConditionFromConfig() {
+    const { conditionOperator, conditionField, conditionValue } = this.config;
+    if (!conditionOperator) {
       return;
     }
-    const { conditionField, conditionOperator, conditionValue } = wc;
     return (output) => {
       const fieldValue = conditionField ? getNestedValue(output, conditionField) : output;
       return evaluateCondition(fieldValue, conditionOperator, conditionValue ?? "");
     };
   }
   analyzeArrayInputs(input) {
-    const wc = this.config.extras?.whileConfig;
-    if (!wc?.iterationInputConfig) {
+    if (!this.config.iterationInputConfig) {
       return null;
     }
     const inputData = input;
-    const config = wc.iterationInputConfig;
+    const config = this.config.iterationInputConfig;
     const arrayPorts = [];
     const scalarPorts = [];
     const iteratedValues = {};
@@ -4051,7 +4179,7 @@ class WhileTask extends GraphAsTask {
     if (!this.hasChildren()) {
       throw new TaskConfigurationError(`${this.type}: No subgraph set for while loop`);
     }
-    const condition = this.condition ?? this.buildConditionFromExtras();
+    const condition = this.condition ?? this.buildConditionFromConfig();
     if (!condition) {
       throw new TaskConfigurationError(`${this.type}: No condition function provided`);
     }
@@ -4096,7 +4224,7 @@ class WhileTask extends GraphAsTask {
     if (!this.hasChildren()) {
       throw new TaskConfigurationError(`${this.type}: No subgraph set for while loop`);
     }
-    const condition = this.condition ?? this.buildConditionFromExtras();
+    const condition = this.condition ?? this.buildConditionFromConfig();
     if (!condition) {
       throw new TaskConfigurationError(`${this.type}: No condition function provided`);
     }
@@ -4166,12 +4294,11 @@ class WhileTask extends GraphAsTask {
     const baseSchema = super.inputSchema();
     if (typeof baseSchema === "boolean")
       return baseSchema;
-    const wc = this.config.extras?.whileConfig;
-    if (!wc?.iterationInputConfig) {
+    if (!this.config.iterationInputConfig) {
       return baseSchema;
     }
     const properties = { ...baseSchema.properties || {} };
-    for (const [key, propConfig] of Object.entries(wc.iterationInputConfig)) {
+    for (const [key, propConfig] of Object.entries(this.config.iterationInputConfig)) {
       if (propConfig.mode === "array" && properties[key]) {
         const scalarSchema = properties[key];
         properties[key] = {
@@ -4580,9 +4707,21 @@ function setTaskQueueRegistry(registry) {
 }
 
 // src/task/JobQueueTask.ts
+var jobQueueTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...graphAsTaskConfigSchema["properties"],
+    queue: {}
+  },
+  additionalProperties: false
+};
+
 class JobQueueTask extends GraphAsTask {
   static type = "JobQueueTask";
   static canRunDirectly = true;
+  static configSchema() {
+    return jobQueueTaskConfigSchema;
+  }
   currentQueueName;
   currentJobId;
   currentRunnerId;
@@ -4713,11 +4852,24 @@ class JobQueueTask extends GraphAsTask {
   }
 }
 // src/task/MapTask.ts
+var mapTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...iteratorTaskConfigSchema["properties"],
+    preserveOrder: { type: "boolean" },
+    flatten: { type: "boolean" }
+  },
+  additionalProperties: false
+};
+
 class MapTask extends IteratorTask {
   static type = "MapTask";
   static category = "Flow Control";
   static title = "Map";
   static description = "Transforms array inputs by running a workflow per item";
+  static configSchema() {
+    return mapTaskConfigSchema;
+  }
   static compoundMerge = PROPERTY_ARRAY;
   static inputSchema() {
     return {
@@ -4780,11 +4932,23 @@ queueMicrotask(() => {
   Workflow.prototype.endMap = CreateEndLoopWorkflow("endMap");
 });
 // src/task/ReduceTask.ts
+var reduceTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...iteratorTaskConfigSchema["properties"],
+    initialValue: {}
+  },
+  additionalProperties: false
+};
+
 class ReduceTask extends IteratorTask {
   static type = "ReduceTask";
   static category = "Flow Control";
   static title = "Reduce";
   static description = "Processes iterated inputs sequentially with an accumulator (fold)";
+  static configSchema() {
+    return reduceTaskConfigSchema;
+  }
   constructor(input = {}, config = {}) {
     const reduceConfig = {
       ...config,
@@ -4884,9 +5048,8 @@ var createSingleTaskFromJSON = (item) => {
   if (!taskClass)
     throw new TaskJSONError(`Task type ${item.type} not found, perhaps not registered?`);
   const taskConfig = {
-    id: item.id,
-    name: item.name,
-    extras: item.extras
+    ...item.config,
+    id: item.id
   };
   const task = new taskClass(item.defaults ?? {}, taskConfig);
   return task;
@@ -5092,6 +5255,7 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
 }
 export {
   wrapSchemaInArray,
+  whileTaskConfigSchema,
   setTaskQueueRegistry,
   serialGraph,
   schemaAcceptsArray,
@@ -5099,15 +5263,20 @@ export {
   removeIterationProperties,
   registerJobQueueFactory,
   registerBaseTasks,
+  reduceTaskConfigSchema,
   pipe,
   parallel,
   mergeChainedOutputToInput,
+  mapTaskConfigSchema,
+  jobQueueTaskConfigSchema,
+  iteratorTaskConfigSchema,
   isTaskStreamable,
   isStrictArraySchema,
   isIterationProperty,
   isFlexibleSchema,
   hasVectorOutput,
   hasVectorLikeInput,
+  graphAsTaskConfigSchema,
   getTaskQueueRegistry,
   getStreamingPorts,
   getPortStreamMode,
@@ -5133,6 +5302,7 @@ export {
   createFlexibleSchema,
   createArraySchema,
   connect,
+  conditionalTaskConfigSchema,
   buildIterationInputSchema,
   addIterationContextToSchema,
   WorkflowError,
@@ -5158,6 +5328,7 @@ export {
   TaskFailedError,
   TaskError,
   TaskConfigurationError,
+  TaskConfigSchema,
   TaskAbortedError,
   Task,
   TASK_OUTPUT_REPOSITORY,
@@ -5187,4 +5358,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=47367645DC674EAF64756E2164756E21
+//# debugId=365A916C098B8CB464756E2164756E21