@workglow/ai 0.2.16 → 0.2.17

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);
       }
     }
   }
@@ -1111,16 +1110,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();
@@ -2030,7 +2029,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 +2199,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 +6680,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 +6858,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 +7277,4 @@ export {
   AiChatInputSchema
 };
 
-//# debugId=89474E7F4F6A44CB64756E2164756E21
+//# debugId=819459ADB283D9E664756E2164756E21