@workglow/ai 0.2.16 → 0.2.18

package/dist/node.js

@@ -14,7 +14,7 @@ import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util/worker";
 class AiProviderRegistry {
   runFnRegistry = new Map;
   streamFnRegistry = new Map;
-  reactiveRunFnRegistry = new Map;
+  previewRunFnRegistry = new Map;
   providers = new Map;
   strategyResolvers = new Map;
   defaultStrategy;
@@ -30,7 +30,7 @@ class AiProviderRegistry {
     for (const [, providerMap] of this.streamFnRegistry) {
       providerMap.delete(name);
     }
-    for (const [, providerMap] of this.reactiveRunFnRegistry) {
+    for (const [, providerMap] of this.previewRunFnRegistry) {
       providerMap.delete(name);
     }
   }
@@ -108,25 +108,24 @@ class AiProviderRegistry {
     const taskTypeMap = this.streamFnRegistry.get(taskType);
     return taskTypeMap?.get(modelProvider);
   }
-  registerAsWorkerReactiveRunFn(modelProvider, taskType) {
-    const reactiveFn = async (input, output, model) => {
+  registerAsWorkerPreviewRunFn(modelProvider, taskType) {
+    const previewFn = async (input, model) => {
       const workerManager = globalServiceRegistry.get(WORKER_MANAGER);
-      return workerManager.callWorkerReactiveFunction(modelProvider, taskType, [
+      return workerManager.callWorkerPreviewFunction(modelProvider, taskType, [
         input,
-        output,
         model
       ]);
     };
-    this.registerReactiveRunFn(modelProvider, taskType, reactiveFn);
+    this.registerPreviewRunFn(modelProvider, taskType, previewFn);
   }
-  registerReactiveRunFn(modelProvider, taskType, reactiveRunFn) {
-    if (!this.reactiveRunFnRegistry.has(taskType)) {
-      this.reactiveRunFnRegistry.set(taskType, new Map);
+  registerPreviewRunFn(modelProvider, taskType, previewRunFn) {
+    if (!this.previewRunFnRegistry.has(taskType)) {
+      this.previewRunFnRegistry.set(taskType, new Map);
     }
-    this.reactiveRunFnRegistry.get(taskType).set(modelProvider, reactiveRunFn);
+    this.previewRunFnRegistry.get(taskType).set(modelProvider, previewRunFn);
   }
-  getReactiveRunFn(modelProvider, taskType) {
-    const taskTypeMap = this.reactiveRunFnRegistry.get(taskType);
+  getPreviewRunFn(modelProvider, taskType) {
+    const taskTypeMap = this.previewRunFnRegistry.get(taskType);
     return taskTypeMap?.get(modelProvider);
   }
   getDirectRunFn(modelProvider, taskType) {
@@ -721,11 +720,11 @@ function resolveAiProviderGpuQueueConcurrency(concurrency) {
 class AiProvider {
   tasks;
   streamTasks;
-  reactiveTasks;
-  constructor(tasks, streamTasks, reactiveTasks) {
+  previewTasks;
+  constructor(tasks, streamTasks, previewTasks) {
     this.tasks = tasks;
     this.streamTasks = streamTasks;
-    this.reactiveTasks = reactiveTasks;
+    this.previewTasks = previewTasks;
   }
   get supportedTaskTypes() {
     return this.taskTypes;
@@ -736,8 +735,8 @@ class AiProvider {
   getStreamFn(taskType) {
     return this.streamTasks?.[taskType];
   }
-  getReactiveRunFn(taskType) {
-    return this.reactiveTasks?.[taskType];
+  getPreviewRunFn(taskType) {
+    return this.previewTasks?.[taskType];
   }
   async register(options = {}) {
     const isInline = !!this.tasks;
@@ -765,7 +764,7 @@ class AiProvider {
       for (const taskType of this.taskTypes) {
         registry.registerAsWorkerRunFn(this.name, taskType);
         registry.registerAsWorkerStreamFn(this.name, taskType);
-        registry.registerAsWorkerReactiveRunFn(this.name, taskType);
+        registry.registerAsWorkerPreviewRunFn(this.name, taskType);
       }
     } else {
       for (const [taskType, fn] of Object.entries(this.tasks)) {
@@ -777,9 +776,9 @@ class AiProvider {
         }
       }
     }
-    if (this.reactiveTasks) {
-      for (const [taskType, fn] of Object.entries(this.reactiveTasks)) {
-        registry.registerReactiveRunFn(this.name, taskType, fn);
+    if (this.previewTasks) {
+      for (const [taskType, fn] of Object.entries(this.previewTasks)) {
+        registry.registerPreviewRunFn(this.name, taskType, fn);
       }
     }
     registry.registerProvider(this);
@@ -802,9 +801,9 @@ class AiProvider {
         workerServer.registerStreamFunction(taskType, fn);
       }
     }
-    if (this.reactiveTasks) {
-      for (const [taskType, fn] of Object.entries(this.reactiveTasks)) {
-        workerServer.registerReactiveFunction(taskType, fn);
+    if (this.previewTasks) {
+      for (const [taskType, fn] of Object.entries(this.previewTasks)) {
+        workerServer.registerPreviewFunction(taskType, fn);
       }
     }
   }
@@ -885,80 +884,11 @@ function TypeSingleOrArray(type) {
   };
 }
 var TypeImageInput = {
-  oneOf: [
-    {
-      type: "string",
-      title: "Image Data",
-      description: "Image as data-uri",
-      format: "image:data-uri"
-    },
-    {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        data: {
-          oneOf: [
-            {
-              type: "object",
-              format: "image:ImageBitmap",
-              title: "ImageBitmap"
-            },
-            {
-              type: "object",
-              format: "image:OffscreenCanvas",
-              title: "OffscreenCanvas"
-            },
-            {
-              type: "object",
-              format: "image:VideoFrame",
-              title: "VideoFrame"
-            },
-            {
-              type: "object",
-              properties: {
-                data: {
-                  type: "array",
-                  items: { type: "number", format: "Uint8Clamped" },
-                  format: "Uint8ClampedArray",
-                  title: "Data",
-                  description: "Data of the image"
-                },
-                width: { type: "number", title: "Width", description: "Width of the image" },
-                height: { type: "number", title: "Height", description: "Height of the image" },
-                channels: {
-                  type: "number",
-                  title: "Channels",
-                  description: "Channels of the image"
-                },
-                rawChannels: {
-                  type: "number",
-                  title: "Raw Channels",
-                  description: "Raw channels of the image"
-                }
-              },
-              additionalProperties: false,
-              required: ["data", "width", "height", "channels"],
-              format: "image:ImageBinary",
-              title: "ImageBinary"
-            }
-          ]
-        },
-        width: { type: "number", title: "Width", description: "Width of the image" },
-        height: { type: "number", title: "Height", description: "Height of the image" },
-        channels: {
-          type: "number",
-          title: "Channels",
-          description: "Channels of the image",
-          minimum: 1,
-          maximum: 4
-        }
-      },
-      required: ["data", "width", "height", "channels"]
-    }
-  ],
+  type: "object",
+  properties: {},
   title: "Image",
-  format: "image",
-  description: "Image as URL or base64-encoded data"
+  description: "Image as data URI, Blob, ImageBitmap, ImageBinary, or GpuImage — hydrated to GpuImage by the runner",
+  format: "image"
 };
 var TypeAudioInput = {
   type: "string",
@@ -1111,16 +1041,16 @@ class AiTask extends Task {
     const model = input.model;
     return model?.provider;
   }
-  async executeReactive(input, output, context) {
+  async executePreview(input, context) {
     const model = input.model;
     if (model && typeof model === "object" && model.provider) {
       const taskType = this.constructor.runtype ?? this.constructor.type;
-      const reactiveFn = getAiProviderRegistry().getReactiveRunFn(model.provider, taskType);
-      if (reactiveFn) {
-        return reactiveFn(input, output, model);
+      const previewFn = getAiProviderRegistry().getPreviewRunFn(model.provider, taskType);
+      if (previewFn) {
+        return previewFn(input, model);
       }
     }
-    return super.executeReactive(input, output, context);
+    return super.executePreview(input, context);
   }
   async validateInput(input) {
     const inputSchema = this.inputSchema();
@@ -1578,23 +1508,25 @@ class AiChatTask extends StreamingAiTask {
 import { CreateWorkflow, Workflow } from "@workglow/task-graph";
 
 // src/task/base/AiVisionTask.ts
-import { Image } from "@workglow/util/media";
 class AiVisionTask extends AiTask {
   static type = "AiVisionTask";
   async getJobInput(input) {
     const jobInput = await super.getJobInput(input);
-    const providerName = input.model.provider;
-    const supports = ["Blob"];
-    if (input.image) {
-      if (typeof providerName === "string" && providerName.startsWith("TENSORFLOW_MEDIAPIPE") && "ImageBitmap" in globalThis) {
-        supports.push("ImageBitmap");
-      } else if (typeof providerName === "string" && providerName.startsWith("TENSORFLOW_MEDIAPIPE") && "VideoFrame" in globalThis) {
-        supports.push("VideoFrame");
+    if (!input.image)
+      return jobInput;
+    const provider = input.model.provider;
+    const wantsBitmap = typeof provider === "string" && provider.startsWith("TENSORFLOW_MEDIAPIPE") && typeof ImageBitmap !== "undefined";
+    const materializeOne = async (img) => {
+      if (wantsBitmap) {
+        const bin = await img.materialize();
+        const id = new ImageData(bin.data, bin.width, bin.height);
+        return createImageBitmap(id);
       }
-      const toSupported = (img) => Image.from(img).toFirstSupported(supports);
-      const image = Array.isArray(input.image) ? await Promise.all(input.image.map(toSupported)) : await toSupported(input.image);
-      jobInput.taskInput.image = image;
-    }
+      return img.materialize();
+    };
+    const value = input.image;
+    const materialized = Array.isArray(value) ? await Promise.all(value.map(materializeOne)) : await materializeOne(value);
+    jobInput.taskInput.image = materialized;
     return jobInput;
   }
 }
@@ -2030,7 +1962,11 @@ Workflow4.prototype.chunkVectorUpsert = CreateWorkflow4(ChunkVectorUpsertTask);
 
 // src/task/ContextBuilderTask.ts
 import { estimateTokens } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow6, Task as Task4, Workflow as Workflow6 } from "@workglow/task-graph";
+import {
+  CreateWorkflow as CreateWorkflow6,
+  Task as Task4,
+  Workflow as Workflow6
+} from "@workglow/task-graph";
 
 // src/task/CountTokensTask.ts
 import { CreateWorkflow as CreateWorkflow5, Workflow as Workflow5 } from "@workglow/task-graph";
@@ -2196,7 +2132,10 @@ class ContextBuilderTask extends Task4 {
   static outputSchema() {
     return outputSchema3;
   }
-  async executeReactive(input, _output, context) {
+  async execute(input, context) {
+    return this.executePreview(input, context);
+  }
+  async executePreview(input, context) {
     const {
       chunks,
       metadata = [],
@@ -6674,7 +6613,10 @@ class VectorQuantizeTask extends Task16 {
   static outputSchema() {
     return outputSchema14;
   }
-  async executeReactive(input) {
+  async execute(input) {
+    return this.executePreview(input);
+  }
+  async executePreview(input) {
     const { vector, targetType, normalize = true } = input;
     const isArray = Array.isArray(vector);
     const vectors = isArray ? vector : [vector];
@@ -6849,7 +6791,15 @@ class VectorSimilarityTask extends GraphAsTask {
   static outputSchema() {
     return SimilarityOutputSchema;
   }
-  async executeReactive({ query, vectors, method, topK }) {
+  async execute(input) {
+    return this.executePreview(input);
+  }
+  async executePreview({
+    query,
+    vectors,
+    method,
+    topK
+  }) {
     let similarities = [];
     const fnName = method;
     const fn = similarityFunctions[fnName];
@@ -7260,4 +7210,4 @@ export {
   AiChatInputSchema
 };
 
-//# debugId=89474E7F4F6A44CB64756E2164756E21
+//# debugId=B789274F7A9B487B64756E2164756E21