@workglow/ai 0.0.57 → 0.0.59

package/dist/bun.js

@@ -7,31 +7,14 @@ import {
   PermanentJobError
 } from "@workglow/job-queue";
 
-// src/model/storage/InMemoryModelRepository.ts
+// src/model/ModelRegistry.ts
+import { createServiceToken, globalServiceRegistry } from "@workglow/util";
+
+// src/model/InMemoryModelRepository.ts
 import { InMemoryTabularRepository } from "@workglow/storage";
 
 // src/model/ModelRepository.ts
 import { EventEmitter } from "@workglow/util";
-var ModelSchema = {
-  type: "object",
-  properties: {
-    name: { type: "string" },
-    details: { type: "string" }
-  },
-  required: ["name", "details"],
-  additionalProperties: false
-};
-var ModelPrimaryKeyNames = ["name"];
-var Task2ModelSchema = {
-  type: "object",
-  properties: {
-    task: { type: "string" },
-    model: { type: "string" }
-  },
-  required: ["task", "model"],
-  additionalProperties: false
-};
-var Task2ModelPrimaryKeyNames = ["task", "model"];
 
 class ModelRepository {
   type = "ModelRepository";
@@ -49,101 +32,101 @@ class ModelRepository {
     return this.events.waitOn(name);
   }
   async addModel(model) {
-    await this.modelTabularRepository.put({ name: model.name, details: JSON.stringify(model) });
-    this.models.set(model.name, model);
+    await this.modelTabularRepository.put(model);
     this.events.emit("model_added", model);
     return model;
   }
   async findModelsByTask(task) {
     if (typeof task != "string")
       return;
-    const junctions = await this.task2ModelTabularRepository.search({ task });
-    if (!junctions || junctions.length === 0)
+    const allModels = await this.modelTabularRepository.getAll();
+    if (!allModels || allModels.length === 0)
+      return;
+    const models = allModels.filter((model) => model.tasks?.includes(task));
+    if (models.length === 0)
       return;
-    const models = [];
-    for (const junction of junctions) {
-      const model = await this.modelTabularRepository.get({ name: junction.model });
-      if (model)
-        models.push(JSON.parse(model.details));
-    }
-    models.forEach((m) => this.models.set(m.name, m));
-    this.taskModels.set(task, models);
     return models;
   }
-  models = new Map;
-  taskModels = new Map;
-  async findTasksByModel(model) {
-    if (typeof model != "string")
+  async findTasksByModel(model_id) {
+    if (typeof model_id != "string")
       return;
-    const junctions = await this.task2ModelTabularRepository.search({ model });
-    if (!junctions || junctions.length === 0)
+    const modelRecord = await this.modelTabularRepository.get({ model_id });
+    if (!modelRecord)
       return;
-    return junctions.map((junction) => junction.task);
+    return modelRecord.tasks && modelRecord.tasks.length > 0 ? modelRecord.tasks : undefined;
   }
   async enumerateAllTasks() {
-    const junctions = await this.task2ModelTabularRepository.getAll();
-    if (!junctions || junctions.length === 0)
+    const allModels = await this.modelTabularRepository.getAll();
+    if (!allModels || allModels.length === 0)
       return;
-    const uniqueTasks = [...new Set(junctions.map((junction) => junction.task))];
-    return uniqueTasks;
+    const uniqueTasks = new Set;
+    for (const model of allModels) {
+      if (model.tasks) {
+        for (const task of model.tasks) {
+          uniqueTasks.add(task);
+        }
+      }
+    }
+    return uniqueTasks.size > 0 ? Array.from(uniqueTasks) : undefined;
   }
   async enumerateAllModels() {
     const models = await this.modelTabularRepository.getAll();
     if (!models || models.length === 0)
       return;
-    const parsedModels = models.map((model) => JSON.parse(model.details));
-    parsedModels.forEach((m) => this.models.set(m.name, m));
-    return parsedModels;
-  }
-  async connectTaskToModel(task, model) {
-    await this.task2ModelTabularRepository.put({ task, model });
-    this.events.emit("task_model_connected", task, model);
+    return models;
   }
-  async findByName(name) {
-    if (typeof name != "string")
+  async findByName(model_id) {
+    if (typeof model_id != "string")
       return;
-    const modelstr = await this.modelTabularRepository.get({ name });
-    if (!modelstr)
-      return;
-    const model = JSON.parse(modelstr.details);
-    this.models.set(model.name, model);
-    return model;
+    const model = await this.modelTabularRepository.get({ model_id });
+    return model ?? undefined;
   }
   async size() {
     return await this.modelTabularRepository.size();
   }
-  async clear() {
-    await this.modelTabularRepository.deleteAll();
-  }
 }
 
-// src/model/storage/InMemoryModelRepository.ts
+// src/model/ModelSchema.ts
+var ModelSchema = {
+  type: "object",
+  properties: {
+    model_id: { type: "string" },
+    tasks: { type: "array", items: { type: "string" } },
+    title: { type: "string" },
+    description: { type: "string" },
+    provider: { type: "string" },
+    providerConfig: { type: "object", default: {} },
+    metadata: { type: "object", default: {} }
+  },
+  required: ["model_id", "tasks", "provider", "title", "description", "providerConfig", "metadata"],
+  additionalProperties: false
+};
+var ModelPrimaryKeyNames = ["model_id"];
+
+// src/model/InMemoryModelRepository.ts
 class InMemoryModelRepository extends ModelRepository {
   modelTabularRepository;
-  task2ModelTabularRepository;
   type = "InMemoryModelRepository";
   constructor() {
     super();
     this.modelTabularRepository = new InMemoryTabularRepository(ModelSchema, ModelPrimaryKeyNames);
-    this.task2ModelTabularRepository = new InMemoryTabularRepository(Task2ModelSchema, Task2ModelPrimaryKeyNames, ["model"]);
   }
 }
 
 // src/model/ModelRegistry.ts
-class FallbackModelRegistry extends InMemoryModelRepository {
+var MODEL_REPOSITORY = createServiceToken("model.repository");
+if (!globalServiceRegistry.has(MODEL_REPOSITORY)) {
+  globalServiceRegistry.register(MODEL_REPOSITORY, () => new InMemoryModelRepository, true);
 }
-var modelRegistry;
 function getGlobalModelRepository() {
-  if (!modelRegistry)
-    modelRegistry = new FallbackModelRegistry;
-  return modelRegistry;
+  return globalServiceRegistry.get(MODEL_REPOSITORY);
 }
 function setGlobalModelRepository(pr) {
-  modelRegistry = pr;
+  globalServiceRegistry.registerInstance(MODEL_REPOSITORY, pr);
 }
 
 // src/provider/AiProviderRegistry.ts
-import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util";
+import { globalServiceRegistry as globalServiceRegistry2, WORKER_MANAGER } from "@workglow/util";
 
 class AiProviderRegistry {
   runFnRegistry = new Map;
@@ -155,7 +138,7 @@ class AiProviderRegistry {
   }
   registerAsWorkerRunFn(modelProvider, taskType) {
     const workerFn = async (input, model, update_progress, signal) => {
-      const workerManager = globalServiceRegistry.get(WORKER_MANAGER);
+      const workerManager = globalServiceRegistry2.get(WORKER_MANAGER);
       const result = await workerManager.callWorkerFunction(modelProvider, taskType, [input, model], {
         signal,
         onProgress: update_progress
@@ -476,25 +459,29 @@ class AiTask extends JobQueueTask {
     config.name ||= `${new.target.type || new.target.name}${input.model ? " with model " + input.model : ""}`;
     super(input, config);
   }
-  async createJob(input, queue) {
+  async getJobInput(input) {
     if (typeof input.model !== "string") {
       console.error("AiTask: Model is not a string", input);
       throw new TaskConfigurationError("AiTask: Model is not a string, only create job for single model tasks");
     }
     const runtype = this.constructor.runtype ?? this.constructor.type;
     const model = await this.getModelForInput(input);
-    const queueName = queue?.queueName ?? await this.getDefaultQueueName(input);
-    if (!queueName) {
+    return {
+      taskType: runtype,
+      aiProvider: model.provider,
+      taskInput: input
+    };
+  }
+  async createJob(input, queueName) {
+    const jobInput = await this.getJobInput(input);
+    const resolvedQueueName = queueName ?? await this.getDefaultQueueName(input);
+    if (!resolvedQueueName) {
       throw new TaskConfigurationError("JobQueueTask: Unable to determine queue for AI provider");
     }
     const job = new AiJob({
-      queueName,
+      queueName: resolvedQueueName,
       jobRunId: this.config.runnerId,
-      input: {
-        taskType: runtype,
-        aiProvider: model.provider,
-        taskInput: input
-      }
+      input: jobInput
     });
     return job;
   }
@@ -533,7 +520,7 @@ class AiTask extends JobQueueTask {
       for (const [key, propSchema] of modelTaskProperties) {
         let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
         for (const model of requestedModels) {
-          const foundModel = taskModels?.find((m) => m.name === model);
+          const foundModel = taskModels?.find((m) => m.model_id === model);
           if (!foundModel) {
             throw new TaskConfigurationError(`AiTask: Missing model for '${key}' named '${model}' for task '${this.type}'`);
           }
@@ -567,7 +554,7 @@ class AiTask extends JobQueueTask {
       const taskModels = await getGlobalModelRepository().findModelsByTask(this.type);
       for (const [key, propSchema] of modelTaskProperties) {
         let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
-        let usingModels = requestedModels.filter((model) => taskModels?.find((m) => m.name === model));
+        let usingModels = requestedModels.filter((model) => taskModels?.find((m) => m.model_id === model));
         usingModels = usingModels.length > 1 ? usingModels : usingModels[0];
         input[key] = usingModels;
       }
@@ -664,7 +651,7 @@ var TypeLanguage = (annotations = {}) => ({
   minLength: 2,
   ...annotations
 });
-function TypeModel(semantic = "model", options = {}) {
+function TypeModelAsString(semantic = "model", options = {}) {
   if (semantic !== "model" && !semantic.startsWith("model:")) {
     throw new Error("Invalid semantic value");
   }
@@ -677,6 +664,11 @@ function TypeModel(semantic = "model", options = {}) {
     type: "string"
   };
 }
+function TypeModel(semantic = "model", options = {}) {
+  return {
+    oneOf: [TypeModelAsString(semantic, options), ModelSchema]
+  };
+}
 var TypeReplicateArray = (type, annotations = {}) => ({
   oneOf: [type, { type: "array", items: type }],
   title: type.title,
@@ -1118,11 +1110,15 @@ var TextTranslationInputSchema = {
     }),
     source_lang: TypeReplicateArray(TypeLanguage({
       title: "Source Language",
-      description: "The source language"
+      description: "The source language",
+      minLength: 2,
+      maxLength: 2
     })),
     target_lang: TypeReplicateArray(TypeLanguage({
       title: "Target Language",
-      description: "The target language"
+      description: "The target language",
+      minLength: 2,
+      maxLength: 2
     })),
     model: modelSchema7
   },
@@ -1139,7 +1135,9 @@ var TextTranslationOutputSchema = {
     },
     target_lang: TypeLanguage({
       title: "Output Language",
-      description: "The output language"
+      description: "The output language",
+      minLength: 2,
+      maxLength: 2
     })
   },
   required: ["text", "target_lang"],
@@ -1294,42 +1292,6 @@ function normalize(vector) {
   }
   return new Float32Array(normalized);
 }
-// src/model/storage/IndexedDbModelRepository.ts
-import { IndexedDbTabularRepository } from "@workglow/storage";
-class IndexedDbModelRepository extends ModelRepository {
-  modelTabularRepository;
-  task2ModelTabularRepository;
-  type = "IndexedDbModelRepository";
-  constructor(tableModels = "models", tableTask2Models = "task2models") {
-    super();
-    this.modelTabularRepository = new IndexedDbTabularRepository(tableModels, ModelSchema, ModelPrimaryKeyNames);
-    this.task2ModelTabularRepository = new IndexedDbTabularRepository(tableTask2Models, Task2ModelSchema, Task2ModelPrimaryKeyNames, ["model"]);
-  }
-}
-// src/model/storage/PostgresModelRepository.ts
-import { PostgresTabularRepository } from "@workglow/storage";
-class PostgresModelRepository extends ModelRepository {
-  type = "PostgresModelRepository";
-  modelTabularRepository;
-  task2ModelTabularRepository;
-  constructor(db, tableModels = "aimodel", tableTask2Models = "aitask2aimodel") {
-    super();
-    this.modelTabularRepository = new PostgresTabularRepository(db, tableModels, ModelSchema, ModelPrimaryKeyNames);
-    this.task2ModelTabularRepository = new PostgresTabularRepository(db, tableTask2Models, Task2ModelSchema, Task2ModelPrimaryKeyNames, ["model"]);
-  }
-}
-// src/model/storage/SqliteModelRepository.ts
-import { SqliteTabularRepository } from "@workglow/storage";
-class SqliteModelRepository extends ModelRepository {
-  type = "SqliteModelRepository";
-  modelTabularRepository;
-  task2ModelTabularRepository;
-  constructor(dbOrPath, tableModels = "aimodel", tableTask2Models = "aitask2aimodel") {
-    super();
-    this.modelTabularRepository = new SqliteTabularRepository(dbOrPath, tableModels, ModelSchema, ModelPrimaryKeyNames);
-    this.task2ModelTabularRepository = new SqliteTabularRepository(dbOrPath, tableTask2Models, Task2ModelSchema, Task2ModelPrimaryKeyNames, ["model"]);
-  }
-}
 export {
   setGlobalModelRepository,
   setAiProviderRegistry,
@@ -1341,6 +1303,7 @@ export {
   VectorSimilarityTask,
   TypedArraySchema,
   TypeReplicateArray,
+  TypeModelAsString,
   TypeModel,
   TypeLanguage,
   TextTranslationTask,
@@ -1368,17 +1331,13 @@ export {
   TextEmbeddingOutputSchema,
   TextEmbeddingInputSchema,
   TextEmbedding,
-  Task2ModelSchema,
-  Task2ModelPrimaryKeyNames,
   TableFragment,
-  SqliteModelRepository,
   SimilarityFn,
   Similarity,
-  PostgresModelRepository,
   ModelSchema,
   ModelRepository,
   ModelPrimaryKeyNames,
-  IndexedDbModelRepository,
+  MODEL_REPOSITORY,
   InMemoryModelRepository,
   ImageFragment,
   DownloadModelTask,
@@ -1395,4 +1354,4 @@ export {
   AiJob
 };
 
-//# debugId=C9DF1A7796A4AD4564756E2164756E21
+//# debugId=B7F9C684EE8646AC64756E2164756E21