@workglow/task-graph 0.0.100 → 0.0.102

package/dist/bun.js

@@ -12,6 +12,35 @@ var TaskStatus = {
   ABORTING: "ABORTING",
   FAILED: "FAILED"
 };
+var TaskConfigSchema = {
+  type: "object",
+  properties: {
+    id: {
+      "x-ui-hidden": true
+    },
+    title: { type: "string" },
+    description: { type: "string" },
+    cacheable: { type: "boolean" },
+    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,
+      "x-ui-hidden": true
+    }
+  },
+  additionalProperties: false
+};
 
 // src/task-graph/Dataflow.ts
 var DATAFLOW_ALL_PORTS = "*";
@@ -718,7 +747,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;
@@ -810,8 +839,11 @@ class Task {
   static type = "Task";
   static category = "Hidden";
   static title = "";
+  static description = "";
   static cacheable = true;
   static hasDynamicSchemas = false;
+  static passthroughInputsToOutputs = false;
+  static customizable = false;
   static inputSchema() {
     return {
       type: "object",
@@ -826,6 +858,9 @@ class Task {
       additionalProperties: false
     };
   }
+  static configSchema() {
+    return TaskConfigSchema;
+  }
   async execute(_input, context) {
     if (context.signal?.aborted) {
       throw new TaskAbortedError("Task aborted");
@@ -842,8 +877,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);
@@ -860,6 +895,9 @@ class Task {
   outputSchema() {
     return this.constructor.outputSchema();
   }
+  configSchema() {
+    return this.constructor.configSchema();
+  }
   get type() {
     return this.constructor.type;
   }
@@ -867,15 +905,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;
@@ -889,16 +931,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();
@@ -935,7 +979,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) {
@@ -1080,6 +1124,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") {
@@ -1107,7 +1182,14 @@ class Task {
     return this.constructor.getInputSchemaNode(type);
   }
   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(this.type);
+    }
     const result = schemaNode.validate(input);
     if (!result.valid) {
       const errorMessages = result.errors.map((e) => {
@@ -1144,12 +1226,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;
   }
@@ -1192,12 +1278,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) {
@@ -1228,7 +1329,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),
@@ -1932,9 +2033,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");
@@ -2098,6 +2197,15 @@ class GraphAsTaskRunner extends TaskRunner {
 }
 
 // src/task/GraphAsTask.ts
+var graphAsTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...TaskConfigSchema["properties"],
+    compoundMerge: { type: "string", "x-ui-hidden": true }
+  },
+  additionalProperties: false
+};
+
 class GraphAsTask extends Task {
   static type = "GraphAsTask";
   static title = "Group";
@@ -2119,11 +2227,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()) {
@@ -3000,17 +3111,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);
@@ -3487,6 +3600,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;
@@ -3534,23 +3657,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;
@@ -3595,6 +3712,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;
   }
@@ -3955,6 +4075,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";
@@ -3962,6 +4096,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;
   }
@@ -3979,38 +4116,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 = {};
@@ -4066,7 +4195,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`);
     }
@@ -4111,7 +4240,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`);
     }
@@ -4181,12 +4310,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] = {
@@ -4595,9 +4723,25 @@ function setTaskQueueRegistry(registry) {
 }
 
 // src/task/JobQueueTask.ts
+var jobQueueTaskConfigSchema = {
+  type: "object",
+  properties: {
+    ...graphAsTaskConfigSchema["properties"],
+    queue: {
+      oneOf: [{ type: "boolean" }, { type: "string" }],
+      description: "Queue handling: false=run inline, true=use default, string=explicit queue name",
+      "x-ui-hidden": true
+    }
+  },
+  additionalProperties: false
+};
+
 class JobQueueTask extends GraphAsTask {
   static type = "JobQueueTask";
   static canRunDirectly = true;
+  static configSchema() {
+    return jobQueueTaskConfigSchema;
+  }
   currentQueueName;
   currentJobId;
   currentRunnerId;
@@ -4728,11 +4872,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 {
@@ -4795,11 +4952,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,
@@ -4899,9 +5068,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;
@@ -5107,6 +5275,7 @@ class TaskOutputTabularRepository extends TaskOutputRepository {
 }
 export {
   wrapSchemaInArray,
+  whileTaskConfigSchema,
   setTaskQueueRegistry,
   serialGraph,
   schemaAcceptsArray,
@@ -5114,15 +5283,20 @@ export {
   removeIterationProperties,
   registerJobQueueFactory,
   registerBaseTasks,
+  reduceTaskConfigSchema,
   pipe,
   parallel,
   mergeChainedOutputToInput,
+  mapTaskConfigSchema,
+  jobQueueTaskConfigSchema,
+  iteratorTaskConfigSchema,
   isTaskStreamable,
   isStrictArraySchema,
   isIterationProperty,
   isFlexibleSchema,
   hasVectorOutput,
   hasVectorLikeInput,
+  graphAsTaskConfigSchema,
   getTaskQueueRegistry,
   getStreamingPorts,
   getPortStreamMode,
@@ -5148,6 +5322,7 @@ export {
   createFlexibleSchema,
   createArraySchema,
   connect,
+  conditionalTaskConfigSchema,
   buildIterationInputSchema,
   addIterationContextToSchema,
   WorkflowError,
@@ -5173,6 +5348,7 @@ export {
   TaskFailedError,
   TaskError,
   TaskConfigurationError,
+  TaskConfigSchema,
   TaskAbortedError,
   Task,
   TASK_OUTPUT_REPOSITORY,
@@ -5202,4 +5378,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=8204DBBC6072784764756E2164756E21
+//# debugId=938C49A4E3822EB264756E2164756E21