@workglow/ai 0.0.58 → 0.0.60

package/dist/model/ModelRepository.d.ts

@@ -5,67 +5,29 @@
  */
 import { type TabularRepository } from "@workglow/storage";
 import { EventEmitter, EventParameters } from "@workglow/util";
-import { Model } from "./Model";
+import { ModelPrimaryKeyNames, ModelRecord, ModelSchema } from "./ModelSchema";
 /**
  * Events that can be emitted by the ModelRepository
  */
 export type ModelEventListeners = {
-    model_added: (model: Model) => void;
-    model_removed: (model: Model) => void;
-    task_model_connected: (task: string, model: string) => void;
-    task_model_disconnected: (task: string, model: string) => void;
-    model_updated: (model: Model) => void;
+    model_added: (model: ModelRecord) => void;
+    model_removed: (model: ModelRecord) => void;
+    model_updated: (model: ModelRecord) => void;
 };
 export type ModelEvents = keyof ModelEventListeners;
 export type ModelEventListener<Event extends ModelEvents> = ModelEventListeners[Event];
 export type ModelEventParameters<Event extends ModelEvents> = EventParameters<ModelEventListeners, Event>;
-export declare const ModelSchema: {
-    readonly type: "object";
-    readonly properties: {
-        readonly name: {
-            readonly type: "string";
-        };
-        readonly details: {
-            readonly type: "string";
-        };
-    };
-    readonly required: readonly ["name", "details"];
-    readonly additionalProperties: false;
-};
-export declare const ModelPrimaryKeyNames: readonly ["name"];
 /**
- * Represents the structure for mapping tasks to models
- */
-export declare const Task2ModelSchema: {
-    readonly type: "object";
-    readonly properties: {
-        readonly task: {
-            readonly type: "string";
-        };
-        readonly model: {
-            readonly type: "string";
-        };
-    };
-    readonly required: readonly ["task", "model"];
-    readonly additionalProperties: false;
-};
-export declare const Task2ModelPrimaryKeyNames: readonly ["task", "model"];
-/**
- * Abstract base class for managing AI models and their relationships with tasks.
+ * Base class for managing AI models and their relationships with tasks.
  * Provides functionality for storing, retrieving, and managing the lifecycle of models
  * and their associations with specific tasks.
  */
-export declare abstract class ModelRepository {
-    /** Repository type identifier */
-    type: string;
+export declare class ModelRepository {
     /**
      * Repository for storing and managing Model instances
      */
-    abstract modelTabularRepository: TabularRepository<typeof ModelSchema, typeof ModelPrimaryKeyNames>;
-    /**
-     * Repository for managing relationships between tasks and models
-     */
-    abstract task2ModelTabularRepository: TabularRepository<typeof Task2ModelSchema, typeof Task2ModelPrimaryKeyNames>;
+    protected readonly modelTabularRepository: TabularRepository<typeof ModelSchema, typeof ModelPrimaryKeyNames>;
+    constructor(modelTabularRepository: TabularRepository<typeof ModelSchema, typeof ModelPrimaryKeyNames>);
     /** Event emitter for repository events */
     protected events: EventEmitter<ModelEventListeners>;
     /**
@@ -96,21 +58,43 @@ export declare abstract class ModelRepository {
      * Adds a new model to the repository
      * @param model - The model instance to add
      */
-    addModel(model: Model): Promise<Model>;
+    addModel(model: ModelRecord): Promise<{
+        title: string;
+        description: string;
+        model_id: string;
+        tasks: string[];
+        provider: string;
+        providerConfig: {
+            [x: string]: unknown;
+        };
+        metadata: {
+            [x: string]: unknown;
+        };
+    }>;
     /**
      * Finds all models associated with a specific task
      * @param task - The task identifier to search for
      * @returns Promise resolving to an array of associated models, or undefined if none found
      */
-    findModelsByTask(task: string): Promise<any[] | undefined>;
-    models: Map<string, Model>;
-    taskModels: Map<string, Model[]>;
+    findModelsByTask(task: string): Promise<{
+        title: string;
+        description: string;
+        model_id: string;
+        tasks: string[];
+        provider: string;
+        providerConfig: {
+            [x: string]: unknown;
+        };
+        metadata: {
+            [x: string]: unknown;
+        };
+    }[] | undefined>;
     /**
      * Finds all tasks associated with a specific model
      * @param model - The model identifier to search for
      * @returns Promise resolving to an array of associated tasks, or undefined if none found
      */
-    findTasksByModel(model: string): Promise<string[] | undefined>;
+    findTasksByModel(model_id: string): Promise<string[] | undefined>;
     /**
      * Enumerates all tasks in the repository
      * @returns Promise resolving to an array of task identifiers
@@ -120,27 +104,41 @@ export declare abstract class ModelRepository {
      * Enumerates all models in the repository
      * @returns Promise resolving to an array of model instances
      */
-    enumerateAllModels(): Promise<any[] | undefined>;
-    /**
-     * Creates an association between a task and a model
-     * @param task - The task identifier
-     * @param model - The model to associate with the task
-     */
-    connectTaskToModel(task: string, model: string): Promise<void>;
+    enumerateAllModels(): Promise<{
+        title: string;
+        description: string;
+        model_id: string;
+        tasks: string[];
+        provider: string;
+        providerConfig: {
+            [x: string]: unknown;
+        };
+        metadata: {
+            [x: string]: unknown;
+        };
+    }[] | undefined>;
     /**
-     * Retrieves a model by its name
-     * @param name - The name of the model to find
+     * Retrieves a model by its identifier
+     * @param modelId - The model_id of the model to find
      * @returns Promise resolving to the found model or undefined if not found
      */
-    findByName(name: string): Promise<any>;
+    findByName(model_id: string): Promise<{
+        title: string;
+        description: string;
+        model_id: string;
+        tasks: string[];
+        provider: string;
+        providerConfig: {
+            [x: string]: unknown;
+        };
+        metadata: {
+            [x: string]: unknown;
+        };
+    } | undefined>;
     /**
      * Gets the total number of models in the repository
      * @returns Promise resolving to the number of stored models
      */
     size(): Promise<number>;
-    /**
-     * Clears all models from the repository
-     */
-    clear(): Promise<void>;
 }
 //# sourceMappingURL=ModelRepository.d.ts.map

package/dist/model/ModelRepository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModelRepository.d.ts","sourceRoot":"","sources":["../../src/model/ModelRepository.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAwB,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACrF,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;GAEG;AAEH,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACpC,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACtC,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5D,uBAAuB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/D,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,mBAAmB,CAAC;AAEpD,MAAM,MAAM,kBAAkB,CAAC,KAAK,SAAS,WAAW,IAAI,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAEvF,MAAM,MAAM,oBAAoB,CAAC,KAAK,SAAS,WAAW,IAAI,eAAe,CAC3E,mBAAmB,EACnB,KAAK,CACN,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;CAQiB,CAAC;AAC1C,eAAO,MAAM,oBAAoB,mBAAoB,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAQY,CAAC;AAC1C,eAAO,MAAM,yBAAyB,4BAA6B,CAAC;AAEpE;;;;GAIG;AACH,8BAAsB,eAAe;IACnC,iCAAiC;IAC1B,IAAI,SAAqB;IAEhC;;OAEG;IACH,QAAQ,CAAC,sBAAsB,EAAE,iBAAiB,CAChD,OAAO,WAAW,EAClB,OAAO,oBAAoB,CAC5B,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,2BAA2B,EAAE,iBAAiB,CACrD,OAAO,gBAAgB,EACvB,OAAO,yBAAyB,CACjC,CAAC;IAEF,0CAA0C;IAC1C,SAAS,CAAC,MAAM,oCAA2C;IAE3D;;;;OAIG;IACH,EAAE,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,kBAAkB,CAAC,KAAK,CAAC;IAIxE;;;;OAIG;IACH,GAAG,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,kBAAkB,CAAC,KAAK,CAAC;IAIzE;;;;OAIG;IACH,IAAI,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,kBAAkB,CAAC,KAAK,CAAC;IAI1E;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI,EAAE,KAAK;IAI7C;;;OAGG;IACG,QAAQ,CAAC,KAAK,EAAE,KAAK;IAO3B;;;;OAIG;IACG,gBAAgB,CAAC,IAAI,EAAE,MAAM;IAcnC,MAAM,qBAA4B;IAClC,UAAU,uBAA8B;IAExC;;;;OAIG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM;IAOpC;;;OAGG;IACG,iBAAiB;IAOvB;;;OAGG;IACG,kBAAkB;IAQxB;;;;OAIG;IACG,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAKpD;;;;OAIG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM;IAS7B;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAI7B;;OAEG;IACG,KAAK;CAGZ"}
+{"version":3,"file":"ModelRepository.d.ts","sourceRoot":"","sources":["../../src/model/ModelRepository.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAE/D,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE/E;;GAEG;AAEH,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC1C,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC5C,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,mBAAmB,CAAC;AAEpD,MAAM,MAAM,kBAAkB,CAAC,KAAK,SAAS,WAAW,IAAI,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAEvF,MAAM,MAAM,oBAAoB,CAAC,KAAK,SAAS,WAAW,IAAI,eAAe,CAC3E,mBAAmB,EACnB,KAAK,CACN,CAAC;AAEF;;;;GAIG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,sBAAsB,EAAE,iBAAiB,CAC1D,OAAO,WAAW,EAClB,OAAO,oBAAoB,CAC5B,CAAC;gBAEA,sBAAsB,EAAE,iBAAiB,CAAC,OAAO,WAAW,EAAE,OAAO,oBAAoB,CAAC;IAK5F,0CAA0C;IAC1C,SAAS,CAAC,MAAM,oCAA2C;IAE3D;;;;OAIG;IACH,EAAE,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,kBAAkB,CAAC,KAAK,CAAC;IAIxE;;;;OAIG;IACH,GAAG,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,kBAAkB,CAAC,KAAK,CAAC;IAIzE;;;;OAIG;IACH,IAAI,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,kBAAkB,CAAC,KAAK,CAAC;IAI1E;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAS,WAAW,EAAE,IAAI,EAAE,KAAK;IAI7C;;;OAGG;IACG,QAAQ,CAAC,KAAK,EAAE,WAAW;;;;;;;;;;;;;IAMjC;;;;OAIG;IACG,gBAAgB,CAAC,IAAI,EAAE,MAAM;;;;;;;;;;;;;IASnC;;;;OAIG;IACG,gBAAgB,CAAC,QAAQ,EAAE,MAAM;IAOvC;;;OAGG;IACG,iBAAiB;IAcvB;;;OAGG;IACG,kBAAkB;;;;;;;;;;;;;IAMxB;;;;OAIG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;IAMjC;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAG9B"}

package/dist/model/ModelSchema.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FromSchema } from "@workglow/util";
+export declare const ModelSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly model_id: {
+            readonly type: "string";
+        };
+        readonly tasks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly title: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+        };
+        readonly provider: {
+            readonly type: "string";
+        };
+        readonly providerConfig: {
+            readonly type: "object";
+            readonly default: {};
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly default: {};
+        };
+    };
+    readonly required: readonly ["model_id", "tasks", "provider", "title", "description", "providerConfig", "metadata"];
+    readonly additionalProperties: false;
+};
+export type ModelRecord = FromSchema<typeof ModelSchema>;
+export declare const ModelPrimaryKeyNames: readonly ["model_id"];
+//# sourceMappingURL=ModelSchema.d.ts.map

package/dist/model/ModelSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelSchema.d.ts","sourceRoot":"","sources":["../../src/model/ModelSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAwB,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAElE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaiB,CAAC;AAE1C,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AACzD,eAAO,MAAM,oBAAoB,uBAAwB,CAAC"}

package/dist/node.js

@@ -6,34 +6,20 @@ 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";
+  modelTabularRepository;
+  constructor(modelTabularRepository) {
+    this.modelTabularRepository = modelTabularRepository;
+  }
   events = new EventEmitter;
   on(name, fn) {
     this.events.on(name, fn);
@@ -48,101 +34,98 @@ 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")
-      return;
-    const modelstr = await this.modelTabularRepository.get({ name });
-    if (!modelstr)
+  async findByName(model_id) {
+    if (typeof model_id != "string")
       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"]);
+    super(new InMemoryTabularRepository(ModelSchema, ModelPrimaryKeyNames));
   }
 }
 
 // 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;
@@ -154,7 +137,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
@@ -536,7 +519,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}'`);
           }
@@ -570,7 +553,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;
       }
@@ -667,7 +650,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");
   }
@@ -680,6 +663,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,
@@ -1303,42 +1291,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,
@@ -1350,6 +1302,7 @@ export {
   VectorSimilarityTask,
   TypedArraySchema,
   TypeReplicateArray,
+  TypeModelAsString,
   TypeModel,
   TypeLanguage,
   TextTranslationTask,
@@ -1377,17 +1330,13 @@ export {
   TextEmbeddingOutputSchema,
   TextEmbeddingInputSchema,
   TextEmbedding,
-  Task2ModelSchema,
-  Task2ModelPrimaryKeyNames,
   TableFragment,
-  SqliteModelRepository,
   SimilarityFn,
   Similarity,
-  PostgresModelRepository,
   ModelSchema,
   ModelRepository,
   ModelPrimaryKeyNames,
-  IndexedDbModelRepository,
+  MODEL_REPOSITORY,
   InMemoryModelRepository,
   ImageFragment,
   DownloadModelTask,
@@ -1404,4 +1353,4 @@ export {
   AiJob
 };
 
-//# debugId=5FEFE6A998AB63D364756E2164756E21
+//# debugId=2B7F40AEBFE9094764756E2164756E21