@workglow/ai 0.0.52

package/dist/browser.js

@@ -0,0 +1,1371 @@
+// src/job/AiJob.ts
+import {
+  AbortSignalJobError,
+  Job,
+  JobStatus,
+  PermanentJobError
+} from "@workglow/job-queue";
+
+// src/model/storage/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";
+  events = new EventEmitter;
+  on(name, fn) {
+    this.events.on(name, fn);
+  }
+  off(name, fn) {
+    this.events.off(name, fn);
+  }
+  once(name, fn) {
+    this.events.once(name, fn);
+  }
+  waitOn(name) {
+    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);
+    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)
+      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")
+      return;
+    const junctions = await this.task2ModelTabularRepository.search({ model });
+    if (!junctions || junctions.length === 0)
+      return;
+    return junctions.map((junction) => junction.task);
+  }
+  async enumerateAllTasks() {
+    const junctions = await this.task2ModelTabularRepository.getAll();
+    if (!junctions || junctions.length === 0)
+      return;
+    const uniqueTasks = [...new Set(junctions.map((junction) => junction.task))];
+    return uniqueTasks;
+  }
+  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);
+  }
+  async findByName(name) {
+    if (typeof name != "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;
+  }
+  async size() {
+    return await this.modelTabularRepository.size();
+  }
+  async clear() {
+    await this.modelTabularRepository.deleteAll();
+  }
+}
+
+// src/model/storage/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 modelRegistry;
+function getGlobalModelRepository() {
+  if (!modelRegistry)
+    modelRegistry = new FallbackModelRegistry;
+  return modelRegistry;
+}
+function setGlobalModelRepository(pr) {
+  modelRegistry = pr;
+}
+
+// src/provider/AiProviderRegistry.ts
+import { globalServiceRegistry, WORKER_MANAGER } from "@workglow/util";
+
+class AiProviderRegistry {
+  runFnRegistry = new Map;
+  registerRunFn(modelProvider, taskType, runFn) {
+    if (!this.runFnRegistry.has(taskType)) {
+      this.runFnRegistry.set(taskType, new Map);
+    }
+    this.runFnRegistry.get(taskType).set(modelProvider, runFn);
+  }
+  registerAsWorkerRunFn(modelProvider, taskType) {
+    const workerFn = async (input, model, update_progress, signal) => {
+      const workerManager = globalServiceRegistry.get(WORKER_MANAGER);
+      const result = await workerManager.callWorkerFunction(modelProvider, taskType, [input, model], {
+        signal,
+        onProgress: update_progress
+      });
+      return result;
+    };
+    this.registerRunFn(modelProvider, taskType, workerFn);
+  }
+  getDirectRunFn(modelProvider, taskType) {
+    const taskTypeMap = this.runFnRegistry.get(taskType);
+    const runFn = taskTypeMap?.get(modelProvider);
+    if (!runFn) {
+      throw new Error(`No run function found for task type ${taskType} and model provider ${modelProvider}`);
+    }
+    return runFn;
+  }
+}
+var providerRegistry;
+function getAiProviderRegistry() {
+  if (!providerRegistry)
+    providerRegistry = new AiProviderRegistry;
+  return providerRegistry;
+}
+function setAiProviderRegistry(pr) {
+  providerRegistry = pr;
+}
+
+// src/job/AiJob.ts
+class AiJob extends Job {
+  async execute(input, context) {
+    if (context.signal.aborted || this.status === JobStatus.ABORTING) {
+      throw new AbortSignalJobError("Abort signal aborted before execution of job");
+    }
+    let abortHandler;
+    try {
+      const abortPromise = new Promise((_resolve, reject) => {
+        const handler = () => {
+          reject(new AbortSignalJobError("Abort signal seen, ending job"));
+        };
+        context.signal.addEventListener("abort", handler, { once: true });
+        abortHandler = () => context.signal.removeEventListener("abort", handler);
+      });
+      const runFn = async () => {
+        const fn = getAiProviderRegistry().getDirectRunFn(input.aiProvider, input.taskType);
+        if (!fn) {
+          throw new PermanentJobError(`No run function found for task type ${input.taskType} and model provider ${input.aiProvider}`);
+        }
+        const modelName = input.taskInput.model;
+        const model = await getGlobalModelRepository().findByName(modelName);
+        if (modelName && !model) {
+          throw new PermanentJobError(`Model ${modelName} not found`);
+        }
+        if (context.signal?.aborted) {
+          throw new AbortSignalJobError("Job aborted");
+        }
+        return await fn(input.taskInput, model, context.updateProgress, context.signal);
+      };
+      const runFnPromise = runFn();
+      return await Promise.race([runFnPromise, abortPromise]);
+    } finally {
+      if (abortHandler) {
+        abortHandler();
+      }
+    }
+  }
+}
+// src/source/Document.ts
+class Document {
+  metadata;
+  constructor(content, metadata = { title: "" }) {
+    this.metadata = metadata;
+    if (content) {
+      if (Array.isArray(content)) {
+        for (const line of content) {
+          this.addContent(line);
+        }
+      } else {
+        this.addContent(content);
+      }
+    }
+  }
+  addContent(content) {
+    if (typeof content === "string") {
+      this.addText(content);
+    } else if (content instanceof DocumentBaseFragment || content instanceof DocumentSection) {
+      this.fragments.push(content);
+    } else {
+      throw new Error("Unknown content type");
+    }
+  }
+  addSection(content, metadata) {
+    const section = new DocumentSection(this, content, metadata);
+    this.fragments.push(section);
+    return section;
+  }
+  addText(content) {
+    const f = new TextFragment(content);
+    this.fragments.push(f);
+    return f;
+  }
+  addImage(content) {
+    const f = new ImageFragment(content);
+    this.fragments.push(f);
+    return f;
+  }
+  addTable(content) {
+    const f = new TableFragment(content);
+    this.fragments.push(f);
+    return f;
+  }
+  fragments = [];
+  toJSON() {
+    return {
+      type: "document" /* DOCUMENT */,
+      metadata: this.metadata,
+      fragments: this.fragments.map((f) => f.toJSON())
+    };
+  }
+}
+
+class DocumentSection extends Document {
+  parent;
+  constructor(parent, content, metadata) {
+    super(content, metadata);
+    this.parent = parent;
+    this.parent = parent;
+  }
+  toJSON() {
+    return {
+      type: "section" /* SECTION */,
+      metadata: this.metadata,
+      fragments: this.fragments.map((f) => f.toJSON())
+    };
+  }
+}
+
+class DocumentBaseFragment {
+  metadata;
+  constructor(metadata) {
+    this.metadata = metadata;
+  }
+}
+
+class TextFragment extends DocumentBaseFragment {
+  content;
+  constructor(content, metadata) {
+    super(metadata);
+    this.content = content;
+  }
+  toJSON() {
+    return {
+      type: "text" /* TEXT */,
+      metadata: this.metadata,
+      content: this.content
+    };
+  }
+}
+
+class TableFragment extends DocumentBaseFragment {
+  content;
+  constructor(content, metadata) {
+    super(metadata);
+    this.content = content;
+  }
+  toJSON() {
+    return {
+      type: "table" /* TABLE */,
+      metadata: this.metadata,
+      content: this.content
+    };
+  }
+}
+
+class ImageFragment extends DocumentBaseFragment {
+  content;
+  constructor(content, metadata) {
+    super(metadata);
+    this.content = content;
+  }
+  toJSON() {
+    return {
+      type: "image" /* IMAGE */,
+      metadata: this.metadata,
+      content: this.content
+    };
+  }
+}
+// src/source/DocumentConverter.ts
+class DocumentConverter {
+  metadata;
+  constructor(metadata) {
+    this.metadata = metadata;
+  }
+}
+
+// src/source/DocumentConverterMarkdown.ts
+class DocumentConverterMarkdown extends DocumentConverter {
+  markdown;
+  constructor(metadata, markdown) {
+    super(metadata);
+    this.markdown = markdown;
+  }
+  convert() {
+    const parser = new MarkdownParser(this.metadata.title);
+    const document = parser.parse(this.markdown);
+    return document;
+  }
+}
+
+class MarkdownParser {
+  document;
+  currentSection;
+  textBuffer = [];
+  constructor(title) {
+    this.document = new Document(title);
+    this.currentSection = this.document;
+  }
+  parse(markdown) {
+    const lines = markdown.split(`
+`);
+    lines.forEach((line, index) => {
+      if (this.isHeader(line)) {
+        this.flushTextBuffer();
+        const { level, content } = this.parseHeader(line);
+        this.currentSection = level === 1 ? this.document.addSection(content) : this.currentSection.addSection(content);
+      } else if (this.isTableStart(line)) {
+        this.flushTextBuffer();
+        const tableLines = this.collectTableLines(lines, index);
+        this.currentSection.addTable(tableLines.join(`
+`));
+      } else if (this.isImageInline(line)) {
+        this.parseLineWithPossibleImages(line);
+      } else {
+        this.textBuffer.push(line);
+      }
+    });
+    this.flushTextBuffer();
+    return this.document;
+  }
+  flushTextBuffer() {
+    if (this.textBuffer.length > 0) {
+      const textContent = this.textBuffer.join(`
+`).trim();
+      if (textContent) {
+        this.currentSection.addText(textContent);
+      }
+      this.textBuffer = [];
+    }
+  }
+  parseLineWithPossibleImages(line) {
+    const parts = line.split(/(!\[.*?\]\(.*?\))/).filter((part) => part !== "");
+    parts.forEach((part) => {
+      if (this.isImage(part)) {
+        const { alt, src } = this.parseImage(part);
+        this.flushTextBuffer();
+        this.currentSection.addImage({ alt, src });
+      } else {
+        this.textBuffer.push(part);
+      }
+    });
+    this.flushTextBuffer();
+  }
+  isHeader(line) {
+    return /^#{1,6}\s/.test(line);
+  }
+  parseHeader(line) {
+    const match = line.match(/^(#{1,6})\s+(.*)$/);
+    return match ? { level: match[1].length, content: match[2] } : { level: 0, content: "" };
+  }
+  isTableStart(line) {
+    return line.trim().startsWith("|") && line.includes("|", line.indexOf("|") + 1);
+  }
+  collectTableLines(lines, startIndex) {
+    const tableLines = [];
+    for (let i = startIndex;i < lines.length && this.isTableLine(lines[i]); i++) {
+      tableLines.push(lines[i]);
+    }
+    return tableLines;
+  }
+  isTableLine(line) {
+    return line.includes("|");
+  }
+  isImageInline(line) {
+    return line.includes("![") && line.includes("](");
+  }
+  isImage(part) {
+    return /^!\[.*\]\(.*\)$/.test(part);
+  }
+  parseImage(markdown) {
+    const match = markdown.match(/^!\[(.*)\]\((.*)\)$/);
+    return match ? { alt: match[1], src: match[2] } : { alt: "", src: "" };
+  }
+}
+// src/source/DocumentConverterText.ts
+class DocumentConverterText extends DocumentConverter {
+  text;
+  constructor(metadata, text) {
+    super(metadata);
+    this.text = text;
+  }
+  convert() {
+    return new Document(this.text, this.metadata);
+  }
+}
+// src/task/base/AiTask.ts
+import {
+  JobQueueTask,
+  TaskConfigurationError
+} from "@workglow/task-graph";
+function schemaFormat(schema) {
+  return typeof schema === "object" && schema !== null && "format" in schema ? schema.format : undefined;
+}
+
+class AiTask extends JobQueueTask {
+  static type = "AiTask";
+  modelCache;
+  constructor(input = {}, config = {}) {
+    config.name ||= `${new.target.type || new.target.name}${input.model ? " with model " + input.model : ""}`;
+    super(input, config);
+  }
+  async createJob(input, queue) {
+    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) {
+      throw new TaskConfigurationError("JobQueueTask: Unable to determine queue for AI provider");
+    }
+    const job = new AiJob({
+      queueName,
+      jobRunId: this.config.runnerId,
+      input: {
+        taskType: runtype,
+        aiProvider: model.provider,
+        taskInput: input
+      }
+    });
+    return job;
+  }
+  async getModelForInput(input) {
+    const modelname = input.model;
+    if (!modelname)
+      throw new TaskConfigurationError("AiTask: No model name found");
+    if (this.modelCache && this.modelCache.name === modelname) {
+      return this.modelCache.model;
+    }
+    const model = await getGlobalModelRepository().findByName(modelname);
+    if (!model) {
+      throw new TaskConfigurationError(`JobQueueTask: No model ${modelname} found`);
+    }
+    this.modelCache = { name: modelname, model };
+    return model;
+  }
+  async getDefaultQueueName(input) {
+    if (typeof input.model === "string") {
+      const model = await this.getModelForInput(input);
+      return model.provider;
+    }
+    return;
+  }
+  async validateInput(input) {
+    const inputSchema = this.inputSchema();
+    if (typeof inputSchema === "boolean") {
+      if (inputSchema === false) {
+        throw new TaskConfigurationError(`AiTask: Input schema is 'false' and accepts no inputs`);
+      }
+      return true;
+    }
+    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
+    if (modelTaskProperties.length > 0) {
+      const taskModels = await getGlobalModelRepository().findModelsByTask(this.type);
+      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);
+          if (!foundModel) {
+            throw new TaskConfigurationError(`AiTask: Missing model for '${key}' named '${model}' for task '${this.type}'`);
+          }
+        }
+      }
+    }
+    const modelPlainProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema) === "model");
+    if (modelPlainProperties.length > 0) {
+      for (const [key, propSchema] of modelPlainProperties) {
+        let requestedModels = Array.isArray(input[key]) ? input[key] : [input[key]];
+        for (const model of requestedModels) {
+          const foundModel = await getGlobalModelRepository().findByName(model);
+          if (!foundModel) {
+            throw new TaskConfigurationError(`AiTask: Missing model for "${key}" named "${model}"`);
+          }
+        }
+      }
+    }
+    return super.validateInput(input);
+  }
+  async narrowInput(input) {
+    const inputSchema = this.inputSchema();
+    if (typeof inputSchema === "boolean") {
+      if (inputSchema === false) {
+        throw new TaskConfigurationError(`AiTask: Input schema is 'false' and accepts no inputs`);
+      }
+      return input;
+    }
+    const modelTaskProperties = Object.entries(inputSchema.properties || {}).filter(([key, schema]) => schemaFormat(schema)?.startsWith("model:"));
+    if (modelTaskProperties.length > 0) {
+      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));
+        usingModels = usingModels.length > 1 ? usingModels : usingModels[0];
+        input[key] = usingModels;
+      }
+    }
+    return input;
+  }
+}
+// src/task/base/AiTaskSchemas.ts
+import {
+  FromSchemaDefaultOptions
+} from "@workglow/util";
+var TypedArrayType = null;
+var TypedArraySchemaOptions = {
+  ...FromSchemaDefaultOptions,
+  deserialize: [
+    {
+      pattern: { format: "TypedArray" },
+      output: TypedArrayType
+    }
+  ]
+};
+var TypedArraySchema = (annotations = {}) => ({
+  oneOf: [
+    {
+      type: "array",
+      items: { type: "number", format: "Float64" },
+      title: "Float64Array",
+      description: "A 64-bit floating point array",
+      format: "Float64Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Float32" },
+      title: "Float32Array",
+      description: "A 32-bit floating point array",
+      format: "Float32Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Int32" },
+      title: "Int32Array",
+      description: "A 32-bit integer array",
+      format: "Int32Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Int16" },
+      title: "Int16Array",
+      description: "A 16-bit integer array",
+      format: "Int16Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Int8" },
+      title: "Int8Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Uint8" },
+      title: "Uint8Array",
+      description: "A 8-bit unsigned integer array",
+      format: "Uint8Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Uint16" },
+      title: "Uint16Array",
+      description: "A 16-bit unsigned integer array",
+      format: "Uint16Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Uint32" },
+      title: "Uint32Array",
+      description: "A 32-bit unsigned integer array",
+      format: "Uint32Array"
+    },
+    {
+      type: "array",
+      items: { type: "number", format: "Uint8Clamped" },
+      title: "Uint8ClampedArray",
+      description: "A 8-bit unsigned integer array with values clamped to 0-255",
+      format: "Uint8ClampedArray"
+    }
+  ],
+  format: "TypedArray",
+  ...annotations
+});
+var TypeLanguage = (annotations = {}) => ({
+  type: "string",
+  title: "Language",
+  description: "The language to use",
+  maxLength: 2,
+  minLength: 2,
+  ...annotations
+});
+function TypeModel(semantic = "model", options = {}) {
+  if (semantic !== "model" && !semantic.startsWith("model:")) {
+    throw new Error("Invalid semantic value");
+  }
+  const taskName = semantic.startsWith("model:") ? semantic.slice(6).replace(/Task$/, "").replaceAll(/[A-Z]/g, (char) => " " + char.toLowerCase()).trim() : null;
+  return {
+    title: "Model",
+    description: `The model ${taskName ? `for ${taskName} ` : "to use"}`,
+    ...options,
+    format: semantic,
+    type: "string"
+  };
+}
+var TypeReplicateArray = (type, annotations = {}) => ({
+  oneOf: [type, { type: "array", items: type }],
+  title: type.title,
+  description: type.description,
+  ...type.format ? { format: type.format } : {},
+  ...annotations,
+  "x-replicate": true
+});
+// src/task/DocumentSplitterTask.ts
+import {
+  CreateWorkflow,
+  Task,
+  TaskRegistry,
+  Workflow
+} from "@workglow/task-graph";
+var inputSchema = {
+  type: "object",
+  properties: {
+    parser: {
+      type: "string",
+      enum: ["txt", "md"],
+      title: "Document Kind",
+      description: "The kind of document (txt or md)"
+    }
+  },
+  required: ["parser"],
+  additionalProperties: false
+};
+var outputSchema = {
+  type: "object",
+  properties: {
+    texts: {
+      type: "array",
+      items: { type: "string" },
+      title: "Text Chunks",
+      description: "The text chunks of the document"
+    }
+  },
+  required: ["texts"],
+  additionalProperties: false
+};
+
+class DocumentSplitterTask extends Task {
+  static type = "DocumentSplitterTask";
+  static category = "Document";
+  static title = "Document Splitter";
+  static description = "Splits documents into text chunks for processing";
+  static inputSchema() {
+    return inputSchema;
+  }
+  static outputSchema() {
+    return outputSchema;
+  }
+  flattenFragmentsToTexts(item) {
+    if (item instanceof Document) {
+      const texts = [];
+      item.fragments.forEach((fragment) => {
+        texts.push(...this.flattenFragmentsToTexts(fragment));
+      });
+      return texts;
+    } else {
+      return [item.content];
+    }
+  }
+  async executeReactive() {
+    return { texts: this.flattenFragmentsToTexts(this.runInputData.file) };
+  }
+}
+TaskRegistry.registerTask(DocumentSplitterTask);
+var DocumentSplitter = (input) => {
+  return new DocumentSplitterTask(input).run();
+};
+Workflow.prototype.DocumentSplitter = CreateWorkflow(DocumentSplitterTask);
+// src/task/DownloadModelTask.ts
+import { CreateWorkflow as CreateWorkflow2, TaskRegistry as TaskRegistry2, Workflow as Workflow2 } from "@workglow/task-graph";
+var modelSchema = TypeReplicateArray(TypeModel("model"));
+var DownloadModelInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema
+  },
+  required: ["model"],
+  additionalProperties: false
+};
+var DownloadModelOutputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema
+  },
+  required: ["model"],
+  additionalProperties: false
+};
+
+class DownloadModelTask extends AiTask {
+  static type = "DownloadModelTask";
+  static category = "AI Text Model";
+  static title = "Download Model";
+  static description = "Downloads and caches AI models locally with progress tracking";
+  static inputSchema() {
+    return DownloadModelInputSchema;
+  }
+  static outputSchema() {
+    return DownloadModelOutputSchema;
+  }
+  static cacheable = false;
+  files = [];
+  constructor(input, config = {}) {
+    super(input, config);
+    this.on("progress", this.processProgress.bind(this));
+    this.on("start", () => {
+      this.files = [];
+    });
+  }
+  processProgress(progress, message = "", details) {
+    if (details?.file) {
+      const file = this.files.find((f) => f.file === details.file);
+      if (file) {
+        file.progress = details.progress;
+      } else {
+        this.files.push({ file: details.file, progress: details.progress });
+      }
+      this.progress = this.files.reduce((acc, f) => acc + f.progress, 0) / this.files.length;
+    } else {
+      this.progress = progress;
+    }
+  }
+}
+TaskRegistry2.registerTask(DownloadModelTask);
+var DownloadModel = (input, config) => {
+  return new DownloadModelTask(input, config).run();
+};
+Workflow2.prototype.DownloadModel = CreateWorkflow2(DownloadModelTask);
+// src/task/TextEmbeddingTask.ts
+import { CreateWorkflow as CreateWorkflow3, TaskRegistry as TaskRegistry3, Workflow as Workflow3 } from "@workglow/task-graph";
+var modelSchema2 = TypeReplicateArray(TypeModel("model:TextEmbeddingTask"));
+var TextEmbeddingInputSchema = {
+  type: "object",
+  properties: {
+    text: TypeReplicateArray({
+      type: "string",
+      title: "Text",
+      description: "The text to embed"
+    }),
+    model: modelSchema2
+  },
+  required: ["text", "model"],
+  additionalProperties: false
+};
+var TextEmbeddingOutputSchema = {
+  type: "object",
+  properties: {
+    vector: TypeReplicateArray(TypedArraySchema({
+      title: "Vector",
+      description: "The vector embedding of the text"
+    }))
+  },
+  required: ["vector"],
+  additionalProperties: false
+};
+
+class TextEmbeddingTask extends AiTask {
+  static type = "TextEmbeddingTask";
+  static category = "AI Text Model";
+  static title = "Text Embedding";
+  static description = "Generates vector embeddings for text to capture semantic meaning";
+  static inputSchema() {
+    return TextEmbeddingInputSchema;
+  }
+  static outputSchema() {
+    return TextEmbeddingOutputSchema;
+  }
+}
+TaskRegistry3.registerTask(TextEmbeddingTask);
+var TextEmbedding = async (input, config) => {
+  return new TextEmbeddingTask(input, config).run();
+};
+Workflow3.prototype.TextEmbedding = CreateWorkflow3(TextEmbeddingTask);
+// src/task/TextGenerationTask.ts
+import { CreateWorkflow as CreateWorkflow4, TaskRegistry as TaskRegistry4, Workflow as Workflow4 } from "@workglow/task-graph";
+var generatedTextSchema = {
+  type: "string",
+  title: "Text",
+  description: "The generated text"
+};
+var modelSchema3 = TypeReplicateArray(TypeModel("model:TextGenerationTask"));
+var TextGenerationInputSchema = {
+  type: "object",
+  properties: {
+    model: modelSchema3,
+    prompt: TypeReplicateArray({
+      type: "string",
+      title: "Prompt",
+      description: "The prompt to generate text from"
+    }),
+    maxTokens: {
+      type: "number",
+      title: "Max Tokens",
+      description: "The maximum number of tokens to generate",
+      minimum: 1,
+      maximum: 4096,
+      "x-ui-group": "Configuration"
+    },
+    temperature: {
+      type: "number",
+      title: "Temperature",
+      description: "The temperature to use for sampling",
+      minimum: 0,
+      maximum: 2,
+      "x-ui-group": "Configuration"
+    },
+    topP: {
+      type: "number",
+      title: "Top-p",
+      description: "The top-p value to use for sampling",
+      minimum: 0,
+      maximum: 1,
+      "x-ui-group": "Configuration"
+    },
+    frequencyPenalty: {
+      type: "number",
+      title: "Frequency Penalty",
+      description: "The frequency penalty to use",
+      minimum: -2,
+      maximum: 2,
+      "x-ui-group": "Configuration"
+    },
+    presencePenalty: {
+      type: "number",
+      title: "Presence Penalty",
+      description: "The presence penalty to use",
+      minimum: -2,
+      maximum: 2,
+      "x-ui-group": "Configuration"
+    }
+  },
+  required: ["model", "prompt"],
+  additionalProperties: false
+};
+var TextGenerationOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      oneOf: [generatedTextSchema, { type: "array", items: generatedTextSchema }],
+      title: generatedTextSchema.title,
+      description: generatedTextSchema.description
+    }
+  },
+  required: ["text"],
+  additionalProperties: false
+};
+
+class TextGenerationTask extends AiTask {
+  static type = "TextGenerationTask";
+  static category = "AI Text Model";
+  static title = "Text Generation";
+  static description = "Generates text from a prompt using language models with configurable parameters";
+  static inputSchema() {
+    return TextGenerationInputSchema;
+  }
+  static outputSchema() {
+    return TextGenerationOutputSchema;
+  }
+}
+TaskRegistry4.registerTask(TextGenerationTask);
+var TextGeneration = (input, config) => {
+  return new TextGenerationTask(input, config).run();
+};
+Workflow4.prototype.TextGeneration = CreateWorkflow4(TextGenerationTask);
+// src/task/TextQuestionAnswerTask.ts
+import { CreateWorkflow as CreateWorkflow5, TaskRegistry as TaskRegistry5, Workflow as Workflow5 } from "@workglow/task-graph";
+var contextSchema = {
+  type: "string",
+  title: "Context",
+  description: "The context of the question"
+};
+var questionSchema = {
+  type: "string",
+  title: "Question",
+  description: "The question to answer"
+};
+var textSchema = {
+  type: "string",
+  title: "Text",
+  description: "The generated text"
+};
+var modelSchema4 = TypeReplicateArray(TypeModel("model:TextQuestionAnswerTask"));
+var TextQuestionAnswerInputSchema = {
+  type: "object",
+  properties: {
+    context: TypeReplicateArray(contextSchema),
+    question: TypeReplicateArray(questionSchema),
+    model: modelSchema4
+  },
+  required: ["context", "question", "model"],
+  additionalProperties: false
+};
+var TextQuestionAnswerOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      oneOf: [textSchema, { type: "array", items: textSchema }],
+      title: textSchema.title,
+      description: textSchema.description
+    }
+  },
+  required: ["text"],
+  additionalProperties: false
+};
+
+class TextQuestionAnswerTask extends AiTask {
+  static type = "TextQuestionAnswerTask";
+  static category = "AI Text Model";
+  static title = "Text Question Answer";
+  static description = "Answers questions based on provided context using language models";
+  static inputSchema() {
+    return TextQuestionAnswerInputSchema;
+  }
+  static outputSchema() {
+    return TextQuestionAnswerOutputSchema;
+  }
+}
+TaskRegistry5.registerTask(TextQuestionAnswerTask);
+var TextQuestionAnswer = (input, config) => {
+  return new TextQuestionAnswerTask(input, config).run();
+};
+Workflow5.prototype.TextQuestionAnswer = CreateWorkflow5(TextQuestionAnswerTask);
+// src/task/TextRewriterTask.ts
+import { CreateWorkflow as CreateWorkflow6, TaskRegistry as TaskRegistry6, Workflow as Workflow6 } from "@workglow/task-graph";
+var modelSchema5 = TypeReplicateArray(TypeModel("model:TextRewriterTask"));
+var TextRewriterInputSchema = {
+  type: "object",
+  properties: {
+    text: TypeReplicateArray({
+      type: "string",
+      title: "Text",
+      description: "The text to rewrite"
+    }),
+    prompt: TypeReplicateArray({
+      type: "string",
+      title: "Prompt",
+      description: "The prompt to direct the rewriting"
+    }),
+    model: modelSchema5
+  },
+  required: ["text", "prompt", "model"],
+  additionalProperties: false
+};
+var TextRewriterOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "The rewritten text"
+    }
+  },
+  required: ["text"],
+  additionalProperties: false
+};
+
+class TextRewriterTask extends AiTask {
+  static type = "TextRewriterTask";
+  static category = "AI Text Model";
+  static title = "Text Rewriter";
+  static description = "Rewrites text according to a given prompt using language models";
+  static inputSchema() {
+    return TextRewriterInputSchema;
+  }
+  static outputSchema() {
+    return TextRewriterOutputSchema;
+  }
+}
+TaskRegistry6.registerTask(TextRewriterTask);
+var TextRewriter = (input, config) => {
+  return new TextRewriterTask(input, config).run();
+};
+Workflow6.prototype.TextRewriter = CreateWorkflow6(TextRewriterTask);
+// src/task/TextSummaryTask.ts
+import { CreateWorkflow as CreateWorkflow7, TaskRegistry as TaskRegistry7, Workflow as Workflow7 } from "@workglow/task-graph";
+var modelSchema6 = TypeReplicateArray(TypeModel("model:TextSummaryTask"));
+var TextSummaryInputSchema = {
+  type: "object",
+  properties: {
+    text: TypeReplicateArray({
+      type: "string",
+      title: "Text",
+      description: "The text to summarize"
+    }),
+    model: modelSchema6
+  },
+  required: ["text", "model"],
+  additionalProperties: false
+};
+var TextSummaryOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "The summarized text"
+    }
+  },
+  required: ["text"],
+  additionalProperties: false
+};
+
+class TextSummaryTask extends AiTask {
+  static type = "TextSummaryTask";
+  static category = "AI Text Model";
+  static title = "Text Summary";
+  static description = "Summarizes text into a shorter form while preserving key information";
+  static inputSchema() {
+    return TextSummaryInputSchema;
+  }
+  static outputSchema() {
+    return TextSummaryOutputSchema;
+  }
+}
+TaskRegistry7.registerTask(TextSummaryTask);
+var TextSummary = async (input, config) => {
+  return new TextSummaryTask(input, config).run();
+};
+Workflow7.prototype.TextSummary = CreateWorkflow7(TextSummaryTask);
+// src/task/TextTranslationTask.ts
+import { CreateWorkflow as CreateWorkflow8, TaskRegistry as TaskRegistry8, Workflow as Workflow8 } from "@workglow/task-graph";
+var modelSchema7 = TypeReplicateArray(TypeModel("model:TextTranslationTask"));
+var translationTextSchema = {
+  type: "string",
+  title: "Text",
+  description: "The translated text"
+};
+var TextTranslationInputSchema = {
+  type: "object",
+  properties: {
+    text: TypeReplicateArray({
+      type: "string",
+      title: "Text",
+      description: "The text to translate"
+    }),
+    source_lang: TypeReplicateArray(TypeLanguage({
+      title: "Source Language",
+      description: "The source language"
+    })),
+    target_lang: TypeReplicateArray(TypeLanguage({
+      title: "Target Language",
+      description: "The target language"
+    })),
+    model: modelSchema7
+  },
+  required: ["text", "source_lang", "target_lang", "model"],
+  additionalProperties: false
+};
+var TextTranslationOutputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      oneOf: [translationTextSchema, { type: "array", items: translationTextSchema }],
+      title: translationTextSchema.title,
+      description: translationTextSchema.description
+    },
+    target_lang: TypeLanguage({
+      title: "Output Language",
+      description: "The output language"
+    })
+  },
+  required: ["text", "target_lang"],
+  additionalProperties: false
+};
+
+class TextTranslationTask extends AiTask {
+  static type = "TextTranslationTask";
+  static category = "AI Text Model";
+  static title = "Text Translation";
+  static description = "Translates text from one language to another using language models";
+  static inputSchema() {
+    return TextTranslationInputSchema;
+  }
+  static outputSchema() {
+    return TextTranslationOutputSchema;
+  }
+}
+TaskRegistry8.registerTask(TextTranslationTask);
+var TextTranslation = (input, config) => {
+  return new TextTranslationTask(input, config).run();
+};
+Workflow8.prototype.TextTranslation = CreateWorkflow8(TextTranslationTask);
+// src/task/VectorSimilarityTask.ts
+import {
+  ArrayTask,
+  CreateWorkflow as CreateWorkflow9,
+  TaskError,
+  TaskRegistry as TaskRegistry9,
+  Workflow as Workflow9
+} from "@workglow/task-graph";
+var SimilarityFn = {
+  COSINE: "cosine",
+  JACCARD: "jaccard",
+  HAMMING: "hamming"
+};
+var SimilarityInputSchema = {
+  type: "object",
+  properties: {
+    query: TypedArraySchema({
+      title: "Query",
+      description: "Query vector to compare against"
+    }),
+    input: {
+      type: "array",
+      items: TypedArraySchema({
+        title: "Input",
+        description: "Array of vectors to compare against the query"
+      })
+    },
+    topK: {
+      type: "number",
+      title: "Top K",
+      description: "Number of top results to return",
+      minimum: 1,
+      default: 10
+    },
+    similarity: {
+      type: "string",
+      enum: Object.values(SimilarityFn),
+      title: "Similarity \uD835\uDC53",
+      description: "Similarity function to use for comparisons",
+      default: SimilarityFn.COSINE
+    }
+  },
+  required: ["query", "input", "similarity"],
+  additionalProperties: false
+};
+var SimilarityOutputSchema = {
+  type: "object",
+  properties: {
+    output: {
+      type: "array",
+      items: TypedArraySchema({
+        title: "Output",
+        description: "Ranked output vectors"
+      })
+    },
+    score: {
+      type: "array",
+      items: {
+        type: "number",
+        title: "Score",
+        description: "Similarity scores for each output vector"
+      }
+    }
+  },
+  required: ["output", "score"],
+  additionalProperties: false
+};
+
+class VectorSimilarityTask extends ArrayTask {
+  static type = "VectorSimilarityTask";
+  static category = "Analysis";
+  static title = "Vector Similarity";
+  static description = "Compares vectors using similarity functions and returns top-K ranked results";
+  static cacheable = true;
+  static inputSchema() {
+    return SimilarityInputSchema;
+  }
+  static outputSchema() {
+    return SimilarityOutputSchema;
+  }
+  async executeReactive({ query, input, similarity, topK }, oldOutput) {
+    let similarities = [];
+    const fns = { cosine };
+    const fnName = similarity;
+    const fn = fns[fnName];
+    for (const embedding of input) {
+      similarities.push({
+        similarity: fn(embedding, query),
+        embedding
+      });
+    }
+    similarities = similarities.sort((a, b) => b.similarity - a.similarity).slice(0, topK);
+    const outputs = similarities.map((s) => s.embedding);
+    const scores = similarities.map((s) => s.similarity);
+    return {
+      output: outputs,
+      score: scores
+    };
+  }
+}
+TaskRegistry9.registerTask(VectorSimilarityTask);
+var Similarity = (input, config) => {
+  return new VectorSimilarityTask(input, config).run();
+};
+Workflow9.prototype.Similarity = CreateWorkflow9(VectorSimilarityTask);
+function inner(arr1, arr2) {
+  return 1 - arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
+}
+function magnitude(arr) {
+  return Math.sqrt(arr.reduce((acc, val) => acc + val * val, 0));
+}
+function cosine(arr1, arr2) {
+  const dotProduct = inner(arr1, arr2);
+  const magnitude1 = magnitude(arr1);
+  const magnitude2 = magnitude(arr2);
+  return 1 - dotProduct / (magnitude1 * magnitude2);
+}
+function normalize(vector) {
+  const mag = magnitude(vector);
+  if (mag === 0) {
+    throw new TaskError("Cannot normalize a zero vector.");
+  }
+  const normalized = vector.map((val) => Number(val) / mag);
+  if (vector instanceof Float64Array) {
+    return new Float64Array(normalized);
+  }
+  if (vector instanceof Float32Array) {
+    return new Float32Array(normalized);
+  }
+  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"]);
+  }
+}
+export {
+  setGlobalModelRepository,
+  setAiProviderRegistry,
+  normalize,
+  magnitude,
+  inner,
+  getGlobalModelRepository,
+  getAiProviderRegistry,
+  VectorSimilarityTask,
+  TypedArraySchema,
+  TypeReplicateArray,
+  TypeModel,
+  TypeLanguage,
+  TextTranslationTask,
+  TextTranslationOutputSchema,
+  TextTranslationInputSchema,
+  TextTranslation,
+  TextSummaryTask,
+  TextSummaryOutputSchema,
+  TextSummaryInputSchema,
+  TextSummary,
+  TextRewriterTask,
+  TextRewriterOutputSchema,
+  TextRewriterInputSchema,
+  TextRewriter,
+  TextQuestionAnswerTask,
+  TextQuestionAnswerOutputSchema,
+  TextQuestionAnswerInputSchema,
+  TextQuestionAnswer,
+  TextGenerationTask,
+  TextGenerationOutputSchema,
+  TextGenerationInputSchema,
+  TextGeneration,
+  TextFragment,
+  TextEmbeddingTask,
+  TextEmbeddingOutputSchema,
+  TextEmbeddingInputSchema,
+  TextEmbedding,
+  Task2ModelSchema,
+  Task2ModelPrimaryKeyNames,
+  TableFragment,
+  SimilarityFn,
+  Similarity,
+  ModelSchema,
+  ModelRepository,
+  ModelPrimaryKeyNames,
+  IndexedDbModelRepository,
+  InMemoryModelRepository,
+  ImageFragment,
+  DownloadModelTask,
+  DownloadModel,
+  DocumentSplitterTask,
+  DocumentSplitter,
+  DocumentSection,
+  DocumentConverterText,
+  DocumentConverterMarkdown,
+  DocumentBaseFragment,
+  Document,
+  AiTask,
+  AiProviderRegistry,
+  AiJob
+};
+
+//# debugId=CB10B0DB935086A564756E2164756E21