@workglow/task-graph 0.1.0 → 0.1.2

package/dist/browser.js

@@ -3658,10 +3658,11 @@ class WorkflowTask extends GraphAsTask {
 }
 
 class Workflow {
-  constructor(cache, parent, iteratorTask) {
+  constructor(cache, parent, iteratorTask, registry) {
     this._outputCache = cache;
     this._parentWorkflow = parent;
     this._iteratorTask = iteratorTask;
+    this._registry = registry ?? parent?._registry;
     this._graph = new TaskGraph({ outputCache: this._outputCache });
     if (!parent) {
       this._onChanged = this._onChanged.bind(this);
@@ -3672,6 +3673,7 @@ class Workflow {
   _dataFlows = [];
   _error = "";
   _outputCache;
+  _registry;
   _abortController;
   _parentWorkflow;
   _iteratorTask;
@@ -3785,7 +3787,7 @@ class Workflow {
       const output = await this.graph.run(input, {
         parentSignal: this._abortController.signal,
         outputCache: this._outputCache,
-        registry: config?.registry
+        registry: config?.registry ?? this._registry
       });
       const results = this.graph.mergeExecuteOutputsToRunOutput(output, PROPERTY_ARRAY);
       this.events.emit("complete");
@@ -3946,7 +3948,7 @@ class Workflow {
     return this;
   }
   addTaskToGraph(taskClass, input, config) {
-    const task = new taskClass(input, config);
+    const task = new taskClass(input, config, this._registry ? { registry: this._registry } : undefined);
     const id = this.graph.addTask(task);
     this.events.emit("changed", id);
     return task;
@@ -3972,7 +3974,7 @@ class Workflow {
       });
       this._dataFlows = [];
     }
-    const loopBuilder = new Workflow(this.outputCache(), this, task);
+    const loopBuilder = new Workflow(this.outputCache(), this, task, this._registry);
     if (parent) {
       loopBuilder._pendingLoopConnect = { parent, iteratorTask: task };
     }
@@ -4558,7 +4560,18 @@ function extractLoopConfig(task) {
   }
   return config;
 }
+function stripUndefined(obj) {
+  if (!obj)
+    return obj;
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== undefined)
+      result[k] = v;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
 function buildMethodArgs(defaults, config, baseIndent = "", columnOffset = 0) {
+  defaults = stripUndefined(defaults);
   const hasDefaults = defaults && Object.keys(defaults).length > 0;
   const hasConfig = Object.keys(config).length > 0;
   if (!hasDefaults && !hasConfig)
@@ -4833,6 +4846,68 @@ queueMicrotask(() => {
   };
   Workflow.prototype.endFallbackWith = CreateEndLoopWorkflow("endFallbackWith");
 });
+// src/task/InputCompactor.ts
+import { getInputCompactors } from "@workglow/util";
+function schemaAllowsString(schema) {
+  if (typeof schema !== "object" || schema === null)
+    return false;
+  const s = schema;
+  if (s.type === "string")
+    return true;
+  const variants = s.oneOf ?? s.anyOf;
+  if (Array.isArray(variants)) {
+    for (const variant of variants) {
+      if (schemaAllowsString(variant))
+        return true;
+    }
+  }
+  return false;
+}
+async function compactSchemaInputs(input, schema, config) {
+  if (typeof schema === "boolean")
+    return input;
+  const properties = schema.properties;
+  if (!properties || typeof properties !== "object")
+    return input;
+  const compactors = getInputCompactors();
+  const compacted = { ...input };
+  for (const [key, propSchema] of Object.entries(properties)) {
+    let value = compacted[key];
+    const format = getSchemaFormat(propSchema);
+    if (format) {
+      let compactor = compactors.get(format);
+      if (!compactor) {
+        const prefix = getFormatPrefix(format);
+        compactor = compactors.get(prefix);
+      }
+      if (compactor) {
+        if (value !== null && value !== undefined && typeof value === "object" && !Array.isArray(value) && schemaAllowsString(propSchema)) {
+          const id = await compactor(value, format, config.registry);
+          if (id !== undefined) {
+            compacted[key] = id;
+            continue;
+          }
+        } else if (Array.isArray(value)) {
+          compacted[key] = await Promise.all(value.map(async (item) => {
+            if (item !== null && item !== undefined && typeof item === "object" && !Array.isArray(item)) {
+              const id = await compactor(item, format, config.registry);
+              return id !== undefined ? id : item;
+            }
+            return item;
+          }));
+          continue;
+        }
+      }
+    }
+    if (value !== null && value !== undefined && typeof value === "object" && !Array.isArray(value)) {
+      const objectSchema = getObjectSchema(propSchema);
+      if (objectSchema) {
+        compacted[key] = await compactSchemaInputs(value, objectSchema, config);
+      }
+    }
+  }
+  return compacted;
+}
 // src/task/IteratorTaskRunner.ts
 import { uuid4 as uuid46 } from "@workglow/util";
 class IteratorTaskRunner extends GraphAsTaskRunner {
@@ -6334,6 +6409,7 @@ queueMicrotask(() => {
 import {
   createServiceToken as createServiceToken3,
   globalServiceRegistry as globalServiceRegistry4,
+  registerInputCompactor,
   registerInputResolver
 } from "@workglow/util";
 var taskConstructors = new Map;
@@ -6376,6 +6452,17 @@ function resolveTaskFromRegistry(id, _format, registry) {
   };
 }
 registerInputResolver("tasks", resolveTaskFromRegistry);
+registerInputCompactor("tasks", (value, _format, registry) => {
+  if (typeof value === "object" && value !== null && "name" in value) {
+    const name = value.name;
+    if (typeof name !== "string")
+      return;
+    const constructors = getTaskConstructors(registry);
+    const ctor = constructors.get(name);
+    return ctor ? name : undefined;
+  }
+  return;
+});
 
 // src/task/TaskJSON.ts
 var createSingleTaskFromJSON = (item, registry, options) => {
@@ -7321,8 +7408,10 @@ export {
   getTaskConstructors,
   getStructuredOutputSchemas,
   getStreamingPorts,
+  getSchemaFormat,
   getPortStreamMode,
   getOutputStreamMode,
+  getObjectSchema,
   getObjectPortId,
   getNestedValue,
   getLastTask,
@@ -7330,6 +7419,7 @@ export {
   getIterationContextSchemaForType,
   getInputModeFromSchema,
   getGlobalTaskConstructors,
+  getFormatPrefix,
   getAppendPortId,
   formatValue,
   findArrayPorts,
@@ -7351,6 +7441,7 @@ export {
   conditionalTaskConfigSchema,
   computeGraphOutputSchema,
   computeGraphInputSchema,
+  compactSchemaInputs,
   calculateNodeDepths,
   buildIterationInputSchema,
   addIterationContextToSchema,
@@ -7414,4 +7505,4 @@ export {
   ConditionalTask
 };
 
-//# debugId=EEF7AA01B1CAEB2364756E2164756E21
+//# debugId=20FE63BF106AB62F64756E2164756E21