@workglow/ai 0.2.15 → 0.2.17

package/dist/bun.js

@@ -15,7 +15,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;
@@ -31,7 +31,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);
     }
   }
@@ -109,25 +109,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) {
@@ -722,11 +721,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;
@@ -737,8 +736,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;
@@ -766,7 +765,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)) {
@@ -778,9 +777,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);
@@ -803,9 +802,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);
       }
     }
   }
@@ -1112,16 +1111,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();
@@ -1708,7 +1707,7 @@ var inputSchema = {
       title: "Knowledge Base",
       description: "The knowledge base instance to search in"
     }),
-    query: TypeSingleOrArray({
+    query: {
       oneOf: [
         { type: "string" },
         TypedArraySchema2({
@@ -1717,12 +1716,19 @@ var inputSchema = {
         })
       ],
       title: "Query",
-      description: "Query string or pre-computed query vector"
-    }),
+      description: "Query string (requires `model`) or pre-computed query vector"
+    },
     model: TypeModel("model:TextEmbeddingTask", {
       title: "Model",
       description: "Text embedding model to use for query embedding (required when query is a string)"
     }),
+    method: {
+      type: "string",
+      enum: ["similarity", "hybrid"],
+      title: "Retrieval Method",
+      description: "Retrieval strategy: 'similarity' (vector only) or 'hybrid' (vector + full-text).",
+      default: "similarity"
+    },
     topK: {
       type: "number",
       title: "Top K",
@@ -1743,6 +1749,14 @@ var inputSchema = {
       maximum: 1,
       default: 0
     },
+    vectorWeight: {
+      type: "number",
+      title: "Vector Weight",
+      description: "For hybrid method: weight for vector similarity (0-1), remainder goes to text relevance",
+      minimum: 0,
+      maximum: 1,
+      default: 0.7
+    },
     returnVectors: {
       type: "boolean",
       title: "Return Vectors",
@@ -1807,7 +1821,7 @@ var outputSchema = {
       title: "Count",
       description: "Number of results returned"
     },
-    query: TypeSingleOrArray({
+    query: {
       oneOf: [
         { type: "string" },
         TypedArraySchema2({
@@ -1817,7 +1831,7 @@ var outputSchema = {
       ],
       title: "Query",
       description: "The query used for retrieval (pass-through)"
-    })
+    }
   },
   required: ["chunks", "chunk_ids", "metadata", "scores", "count", "query"],
   additionalProperties: false
@@ -1827,7 +1841,7 @@ class ChunkRetrievalTask extends Task2 {
   static type = "ChunkRetrievalTask";
   static category = "RAG";
   static title = "Chunk Retrieval";
-  static description = "End-to-end retrieval: embed query and search for similar chunks";
+  static description = "End-to-end retrieval: embed query (if string) and search the knowledge base. Supports similarity and hybrid methods.";
   static cacheable = true;
   static inputSchema() {
     return inputSchema;
@@ -1842,332 +1856,46 @@ class ChunkRetrievalTask extends Task2 {
       topK = 5,
       filter,
       model,
+      method = "similarity",
+      vectorWeight = 0.7,
       scoreThreshold = 0,
       returnVectors = false
     } = input;
     const kb = knowledgeBase;
-    let queryVectors;
-    if (typeof query === "string" || Array.isArray(query) && query.every((q) => typeof q === "string")) {
+    const queryIsString = typeof query === "string";
+    if (method === "hybrid" && !queryIsString) {
+      throw new Error("Hybrid retrieval requires a string query (it will be embedded and used for full-text search).");
+    }
+    if (method === "hybrid" && !kb.supportsHybridSearch()) {
+      throw new Error("The provided knowledge base does not support hybrid search. Use method: 'similarity' or a backend with hybrid support (e.g., Postgres with pgvector).");
+    }
+    let queryVector;
+    let queryText;
+    if (queryIsString) {
       if (!model) {
         throw new Error("Model is required when query is a string. Please provide a model with format 'model:TextEmbeddingTask'.");
       }
+      queryText = query;
       const embeddingTask = context.own(new TextEmbeddingTask);
       const embeddingResult = await embeddingTask.run({ text: query, model });
-      queryVectors = Array.isArray(embeddingResult.vector) ? embeddingResult.vector : [embeddingResult.vector];
-    } else if (isTypedArray(query) || Array.isArray(query) && query.every(isTypedArray)) {
-      queryVectors = Array.isArray(query) ? query : [query];
+      const vec = embeddingResult.vector;
+      queryVector = Array.isArray(vec) ? vec[0] : vec;
+    } else if (isTypedArray(query)) {
+      queryVector = query;
     } else {
-      throw new Error("Query must be a string, array of strings, or TypedArray");
-    }
-    const searchVectors = queryVectors.map((v) => v instanceof Float32Array ? v : new Float32Array(v));
-    const results = [];
-    for (const searchVector of searchVectors) {
-      const res = await kb.similaritySearch(searchVector, {
-        topK,
-        filter,
-        scoreThreshold
-      });
-      results.push(...res);
-    }
-    const chunks = results.map((r) => {
-      const meta = r.metadata;
-      return meta.text || JSON.stringify(meta);
-    });
-    const output = {
-      chunks,
-      chunk_ids: results.map((r) => r.chunk_id),
-      metadata: results.map((r) => r.metadata),
-      scores: results.map((r) => r.score),
-      count: results.length,
-      query
-    };
-    if (returnVectors) {
-      output.vectors = results.map((r) => r.vector);
+      throw new Error("Query must be a string or TypedArray");
     }
-    return output;
-  }
-}
-var chunkRetrieval = (input, config) => {
-  return new ChunkRetrievalTask(config).run(input);
-};
-Workflow3.prototype.chunkRetrieval = CreateWorkflow3(ChunkRetrievalTask);
-
-// src/task/ChunkToVectorTask.ts
-import { ChunkRecordSchema } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow4, Task as Task3, Workflow as Workflow4 } from "@workglow/task-graph";
-import {
-  TypedArraySchema as TypedArraySchema3
-} from "@workglow/util/schema";
-var inputSchema2 = {
-  type: "object",
-  properties: {
-    doc_id: {
-      type: "string",
-      title: "Document ID",
-      description: "The document ID"
-    },
-    doc_title: {
-      type: "string",
-      title: "Document Title",
-      description: "Human-readable title for the source document"
-    },
-    chunks: {
-      type: "array",
-      items: ChunkRecordSchema(),
-      title: "Chunks",
-      description: "Array of chunk records"
-    },
-    vector: {
-      type: "array",
-      items: TypedArraySchema3({
-        title: "Vector",
-        description: "Vector embedding"
-      }),
-      title: "Vectors",
-      description: "Embeddings from TextEmbeddingTask"
-    }
-  },
-  required: ["chunks", "vector"],
-  additionalProperties: false
-};
-var outputSchema2 = {
-  type: "object",
-  properties: {
-    ids: {
-      type: "array",
-      items: { type: "string" },
-      title: "IDs",
-      description: "Chunk IDs for vector store"
-    },
-    vectors: {
-      type: "array",
-      items: TypedArraySchema3({
-        title: "Vector",
-        description: "Vector embedding"
-      }),
-      title: "Vectors",
-      description: "Vector embeddings"
-    },
-    metadata: {
-      type: "array",
-      items: {
-        type: "object",
-        title: "Metadata",
-        description: "Metadata for vector store"
-      },
-      title: "Metadata",
-      description: "Metadata for each vector"
-    },
-    texts: {
-      type: "array",
-      items: { type: "string" },
-      title: "Texts",
-      description: "Chunk texts (for reference)"
-    }
-  },
-  required: ["ids", "vectors", "metadata", "texts"],
-  additionalProperties: false
-};
-
-class ChunkToVectorTask extends Task3 {
-  static type = "ChunkToVectorTask";
-  static category = "Document";
-  static title = "Chunk to Vector";
-  static description = "Transform chunks and embeddings to vector store format";
-  static cacheable = true;
-  static inputSchema() {
-    return inputSchema2;
-  }
-  static outputSchema() {
-    return outputSchema2;
-  }
-  async execute(input, context) {
-    const { chunks, vector, doc_title } = input;
-    const chunkArray = chunks;
-    if (!chunkArray || !vector) {
-      throw new Error("Both chunks and vector are required");
-    }
-    if (chunkArray.length !== vector.length) {
-      throw new Error(`Mismatch: ${chunkArray.length} chunks but ${vector.length} vectors`);
-    }
-    const ids = [];
-    const metadata = [];
-    const texts = [];
-    for (let i = 0;i < chunkArray.length; i++) {
-      const chunk = chunkArray[i];
-      ids.push(chunk.chunkId);
-      texts.push(chunk.text);
-      metadata.push({
-        doc_id: chunk.doc_id,
-        chunkId: chunk.chunkId,
-        leafNodeId: chunk.nodePath[chunk.nodePath.length - 1],
-        depth: chunk.depth,
-        text: chunk.text,
-        nodePath: chunk.nodePath,
-        ...doc_title ? { doc_title } : {},
-        ...chunk.summary ? { summary: chunk.summary } : {},
-        ...chunk.entities ? { entities: chunk.entities } : {}
-      });
-    }
-    return {
-      ids,
-      vectors: vector,
-      metadata,
-      texts
-    };
-  }
-}
-var chunkToVector = (input, config) => {
-  return new ChunkToVectorTask(config).run(input);
-};
-Workflow4.prototype.chunkToVector = CreateWorkflow4(ChunkToVectorTask);
-
-// src/task/ChunkVectorHybridSearchTask.ts
-import { TypeKnowledgeBase as TypeKnowledgeBase2 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
-import {
-  TypedArraySchema as TypedArraySchema4
-} from "@workglow/util/schema";
-var inputSchema3 = {
-  type: "object",
-  properties: {
-    knowledgeBase: TypeKnowledgeBase2({
-      title: "Knowledge Base",
-      description: "The knowledge base instance to search in (must support hybridSearch)"
-    }),
-    queryVector: TypedArraySchema4({
-      title: "Query Vector",
-      description: "The query vector for semantic search"
-    }),
-    queryText: {
-      type: "string",
-      title: "Query Text",
-      description: "The query text for full-text search"
-    },
-    topK: {
-      type: "number",
-      title: "Top K",
-      description: "Number of top results to return",
-      minimum: 1,
-      default: 10
-    },
-    filter: {
-      type: "object",
-      title: "Metadata Filter",
-      description: "Filter results by metadata fields"
-    },
-    scoreThreshold: {
-      type: "number",
-      title: "Score Threshold",
-      description: "Minimum combined score threshold (0-1)",
-      minimum: 0,
-      maximum: 1,
-      default: 0
-    },
-    vectorWeight: {
-      type: "number",
-      title: "Vector Weight",
-      description: "Weight for vector similarity (0-1), remainder goes to text relevance",
-      minimum: 0,
-      maximum: 1,
-      default: 0.7
-    },
-    returnVectors: {
-      type: "boolean",
-      title: "Return Vectors",
-      description: "Whether to return vector embeddings in results",
-      default: false
-    }
-  },
-  required: ["knowledgeBase", "queryVector", "queryText"],
-  additionalProperties: false
-};
-var outputSchema3 = {
-  type: "object",
-  properties: {
-    chunks: {
-      type: "array",
-      items: { type: "string" },
-      title: "Text Chunks",
-      description: "Retrieved text chunks"
-    },
-    chunk_ids: {
-      type: "array",
-      items: { type: "string" },
-      title: "Chunk IDs",
-      description: "IDs of retrieved chunks"
-    },
-    metadata: {
-      type: "array",
-      items: {
-        type: "object",
-        title: "Metadata",
-        description: "Metadata of retrieved chunk"
-      },
-      title: "Metadata",
-      description: "Metadata of retrieved chunks"
-    },
-    scores: {
-      type: "array",
-      items: { type: "number" },
-      title: "Scores",
-      description: "Combined relevance scores for each result"
-    },
-    vectors: {
-      type: "array",
-      items: TypedArraySchema4({
-        title: "Vector",
-        description: "Vector embedding"
-      }),
-      title: "Vectors",
-      description: "Vector embeddings (if returnVectors is true)"
-    },
-    count: {
-      type: "number",
-      title: "Count",
-      description: "Number of results returned"
-    },
-    query: {
-      type: "string",
-      title: "Query",
-      description: "The text query used for search (pass-through)"
-    }
-  },
-  required: ["chunks", "chunk_ids", "metadata", "scores", "count", "query"],
-  additionalProperties: false
-};
-
-class ChunkVectorHybridSearchTask extends Task4 {
-  static type = "ChunkVectorHybridSearchTask";
-  static category = "RAG";
-  static title = "Hybrid Search";
-  static description = "Combined vector + full-text search for improved retrieval";
-  static cacheable = true;
-  static inputSchema() {
-    return inputSchema3;
-  }
-  static outputSchema() {
-    return outputSchema3;
-  }
-  async execute(input, context) {
-    const {
-      knowledgeBase,
-      queryVector,
-      queryText,
-      topK = 10,
-      filter,
-      scoreThreshold = 0,
-      vectorWeight = 0.7,
-      returnVectors = false
-    } = input;
-    const kb = knowledgeBase;
     const searchVector = queryVector instanceof Float32Array ? queryVector : new Float32Array(queryVector);
-    const results = await kb.hybridSearch(searchVector, {
+    const results = method === "hybrid" ? await kb.hybridSearch(searchVector, {
       textQuery: queryText,
       topK,
       filter,
       scoreThreshold,
       vectorWeight
+    }) : await kb.similaritySearch(searchVector, {
+      topK,
+      filter,
+      scoreThreshold
     });
     const chunks = results.map((r) => {
       const meta = r.metadata;
@@ -2179,7 +1907,7 @@ class ChunkVectorHybridSearchTask extends Task4 {
       metadata: results.map((r) => r.metadata),
       scores: results.map((r) => r.score),
       count: results.length,
-      query: queryText
+      query
     };
     if (returnVectors) {
       output.vectors = results.map((r) => r.vector);
@@ -2187,163 +1915,39 @@ class ChunkVectorHybridSearchTask extends Task4 {
     return output;
   }
 }
-var hybridSearch = async (input, config) => {
-  return new ChunkVectorHybridSearchTask(config).run(input);
-};
-Workflow5.prototype.hybridSearch = CreateWorkflow5(ChunkVectorHybridSearchTask);
-
-// src/task/ChunkVectorSearchTask.ts
-import { TypeKnowledgeBase as TypeKnowledgeBase3 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow6, Task as Task5, Workflow as Workflow6 } from "@workglow/task-graph";
-import {
-  TypedArraySchema as TypedArraySchema5
-} from "@workglow/util/schema";
-var inputSchema4 = {
-  type: "object",
-  properties: {
-    knowledgeBase: TypeKnowledgeBase3({
-      title: "Knowledge Base",
-      description: "The knowledge base instance to search in"
-    }),
-    query: TypedArraySchema5({
-      title: "Query Vector",
-      description: "The query vector to search for similar vectors"
-    }),
-    topK: {
-      type: "number",
-      title: "Top K",
-      description: "Number of top results to return",
-      minimum: 1,
-      default: 10
-    },
-    filter: {
-      type: "object",
-      title: "Metadata Filter",
-      description: "Filter results by metadata fields"
-    },
-    scoreThreshold: {
-      type: "number",
-      title: "Score Threshold",
-      description: "Minimum similarity score threshold (0-1)",
-      minimum: 0,
-      maximum: 1,
-      default: 0
-    }
-  },
-  required: ["knowledgeBase", "query"],
-  additionalProperties: false
-};
-var outputSchema4 = {
-  type: "object",
-  properties: {
-    ids: {
-      type: "array",
-      items: { type: "string" },
-      title: "IDs",
-      description: "IDs of matching vectors"
-    },
-    vectors: {
-      type: "array",
-      items: TypedArraySchema5({
-        title: "Vector",
-        description: "Matching vector embedding"
-      }),
-      title: "Vectors",
-      description: "Matching vector embeddings"
-    },
-    metadata: {
-      type: "array",
-      items: {
-        type: "object",
-        title: "Metadata",
-        description: "Metadata of matching vector"
-      },
-      title: "Metadata",
-      description: "Metadata of matching vectors"
-    },
-    scores: {
-      type: "array",
-      items: { type: "number" },
-      title: "Scores",
-      description: "Similarity scores for each result"
-    },
-    count: {
-      type: "number",
-      title: "Count",
-      description: "Number of results returned"
-    }
-  },
-  required: ["ids", "vectors", "metadata", "scores", "count"],
-  additionalProperties: false
-};
-
-class ChunkVectorSearchTask extends Task5 {
-  static type = "ChunkVectorSearchTask";
-  static category = "Vector Store";
-  static title = "Vector Store Search";
-  static description = "Search for similar vectors in a knowledge base";
-  static cacheable = true;
-  static inputSchema() {
-    return inputSchema4;
-  }
-  static outputSchema() {
-    return outputSchema4;
-  }
-  async execute(input, _context) {
-    const { knowledgeBase, query, topK = 10, filter, scoreThreshold = 0 } = input;
-    const kb = knowledgeBase;
-    const results = await kb.similaritySearch(query, {
-      topK,
-      filter,
-      scoreThreshold
-    });
-    return {
-      ids: results.map((r) => r.chunk_id),
-      vectors: results.map((r) => r.vector),
-      metadata: results.map((r) => r.metadata),
-      scores: results.map((r) => r.score),
-      count: results.length
-    };
-  }
-}
-var vectorStoreSearch = (input, config) => {
-  return new ChunkVectorSearchTask(config).run(input);
+var chunkRetrieval = (input, config) => {
+  return new ChunkRetrievalTask(config).run(input);
 };
-Workflow6.prototype.vectorStoreSearch = CreateWorkflow6(ChunkVectorSearchTask);
+Workflow3.prototype.chunkRetrieval = CreateWorkflow3(ChunkRetrievalTask);
 
 // src/task/ChunkVectorUpsertTask.ts
-import { TypeKnowledgeBase as TypeKnowledgeBase4 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow7, Task as Task6, Workflow as Workflow7 } from "@workglow/task-graph";
+import { ChunkRecordArraySchema, TypeKnowledgeBase as TypeKnowledgeBase2 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow4, Task as Task3, Workflow as Workflow4 } from "@workglow/task-graph";
 import {
-  TypedArraySchema as TypedArraySchema6
+  TypedArraySchema as TypedArraySchema3
 } from "@workglow/util/schema";
-var inputSchema5 = {
+var inputSchema2 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase4({
+    knowledgeBase: TypeKnowledgeBase2({
       title: "Knowledge Base",
       description: "The knowledge base instance to store vectors in"
     }),
-    doc_id: {
-      type: "string",
-      title: "Document ID",
-      description: "The document ID"
-    },
-    vectors: TypeSingleOrArray(TypedArraySchema6({
+    chunks: ChunkRecordArraySchema,
+    vector: TypeSingleOrArray(TypedArraySchema3({
       title: "Vectors",
-      description: "The vector embeddings"
+      description: "The vector embeddings, aligned 1:1 with chunks"
     })),
-    metadata: TypeSingleOrArray({
-      type: "object",
-      title: "Metadata",
-      description: "Metadata associated with the vector",
-      additionalProperties: true
-    })
+    doc_title: {
+      type: "string",
+      title: "Document Title",
+      description: "Optional human-readable title stamped onto each chunk's metadata"
+    }
   },
-  required: ["knowledgeBase", "doc_id", "vectors", "metadata"],
+  required: ["knowledgeBase", "chunks", "vector"],
   additionalProperties: false
 };
-var outputSchema5 = {
+var outputSchema2 = {
   type: "object",
   properties: {
     count: {
@@ -2354,7 +1958,7 @@ var outputSchema5 = {
     doc_id: {
       type: "string",
       title: "Document ID",
-      description: "The document ID"
+      description: "The document ID (read from the first chunk)"
     },
     chunk_ids: {
       type: "array",
@@ -2367,74 +1971,73 @@ var outputSchema5 = {
   additionalProperties: false
 };
 
-class ChunkVectorUpsertTask extends Task6 {
+class ChunkVectorUpsertTask extends Task3 {
   static type = "ChunkVectorUpsertTask";
   static category = "Vector Store";
   static title = "Add to Vector Store";
-  static description = "Store vector embeddings with metadata in a knowledge base";
+  static description = "Store chunks + their embeddings in a knowledge base (1:1 aligned)";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema5;
+    return inputSchema2;
   }
   static outputSchema() {
-    return outputSchema5;
+    return outputSchema2;
   }
   async execute(input, context) {
-    const { knowledgeBase, doc_id, vectors, metadata } = input;
-    const vectorArray = Array.isArray(vectors) ? vectors : [vectors];
-    const metadataArray = Array.isArray(metadata) ? metadata : Array(vectorArray.length).fill(metadata);
+    const { knowledgeBase, chunks, vector, doc_title } = input;
+    const chunkArray = chunks;
+    const vectorArray = Array.isArray(vector) ? vector : [vector];
+    if (chunkArray.length !== vectorArray.length) {
+      throw new Error(`Mismatch: ${chunkArray.length} chunks but ${vectorArray.length} vectors \u2014 they must be 1:1 aligned`);
+    }
+    if (chunkArray.length === 0) {
+      return { doc_id: "", chunk_ids: [], count: 0 };
+    }
     const kb = knowledgeBase;
-    await context.updateProgress(1, "Upserting vectors");
-    if (vectorArray.length > 1) {
-      if (vectorArray.length !== metadataArray.length) {
-        throw new Error("Mismatch: vectors and metadata arrays must have the same length");
+    const doc_id = chunkArray[0].doc_id;
+    for (let i = 1;i < chunkArray.length; i++) {
+      if (chunkArray[i].doc_id !== doc_id) {
+        throw new Error(`ChunkVectorUpsertTask expects all chunks to share one doc_id, but chunk[${i}] has doc_id=${JSON.stringify(chunkArray[i].doc_id)} (expected ${JSON.stringify(doc_id)}).`);
       }
-      const entities = vectorArray.map((vector, i) => {
-        const metadataItem = metadataArray[i];
-        return {
-          doc_id,
-          vector,
-          metadata: metadataItem
-        };
-      });
-      const results = await kb.upsertChunksBulk(entities);
-      const chunk_ids = results.map((r) => r.chunk_id);
-      return {
-        doc_id,
-        chunk_ids,
-        count: chunk_ids.length
+    }
+    await context.updateProgress(1, "Upserting vectors");
+    const entities = chunkArray.map((chunk, i) => {
+      const leafNodeId = chunk.leafNodeId ?? chunk.nodePath[chunk.nodePath.length - 1] ?? undefined;
+      const metadata = {
+        ...chunk,
+        ...leafNodeId !== undefined ? { leafNodeId } : {},
+        ...doc_title ? { doc_title } : {}
       };
-    } else if (vectorArray.length === 1) {
-      const metadataItem = metadataArray[0];
-      const result = await kb.upsertChunk({
-        doc_id,
-        vector: vectorArray[0],
-        metadata: metadataItem
-      });
       return {
-        doc_id,
-        chunk_ids: [result.chunk_id],
-        count: 1
+        doc_id: chunk.doc_id,
+        vector: vectorArray[i],
+        metadata
       };
-    }
+    });
+    const results = await kb.upsertChunksBulk(entities);
+    const chunk_ids = results.map((r) => r.chunk_id);
     return {
       doc_id,
-      chunk_ids: [],
-      count: 0
+      chunk_ids,
+      count: chunk_ids.length
     };
   }
 }
 var chunkVectorUpsert = (input, config) => {
   return new ChunkVectorUpsertTask(config).run(input);
 };
-Workflow7.prototype.chunkVectorUpsert = CreateWorkflow7(ChunkVectorUpsertTask);
+Workflow4.prototype.chunkVectorUpsert = CreateWorkflow4(ChunkVectorUpsertTask);
 
 // src/task/ContextBuilderTask.ts
 import { estimateTokens } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } 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 CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow5, Workflow as Workflow5 } from "@workglow/task-graph";
 var modelSchema4 = TypeModel("model");
 var CountTokensInputSchema = {
   type: "object",
@@ -2478,7 +2081,7 @@ class CountTokensTask extends AiTask {
 var countTokens = async (input, config) => {
   return new CountTokensTask(config).run(input);
 };
-Workflow8.prototype.countTokens = CreateWorkflow8(CountTokensTask);
+Workflow5.prototype.countTokens = CreateWorkflow5(CountTokensTask);
 
 // src/task/ContextBuilderTask.ts
 var ContextFormat = {
@@ -2492,7 +2095,7 @@ var modelSchema5 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting (optional, falls back to estimation)"
 });
-var inputSchema6 = {
+var inputSchema3 = {
   type: "object",
   properties: {
     chunks: {
@@ -2557,7 +2160,7 @@ var inputSchema6 = {
   required: ["chunks"],
   additionalProperties: false
 };
-var outputSchema6 = {
+var outputSchema3 = {
   type: "object",
   properties: {
     context: {
@@ -2585,19 +2188,22 @@ var outputSchema6 = {
   additionalProperties: false
 };
 
-class ContextBuilderTask extends Task7 {
+class ContextBuilderTask extends Task4 {
   static type = "ContextBuilderTask";
   static category = "RAG";
   static title = "Context Builder";
   static description = "Format retrieved chunks into context for LLM prompts";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema6;
+    return inputSchema3;
   }
   static outputSchema() {
-    return outputSchema6;
+    return outputSchema3;
+  }
+  async execute(input, context) {
+    return this.executePreview(input, context);
   }
-  async executeReactive(input, _output, context) {
+  async executePreview(input, context) {
     const {
       chunks,
       metadata = [],
@@ -2778,14 +2384,14 @@ class ContextBuilderTask extends Task7 {
 var contextBuilder = (input, config) => {
   return new ContextBuilderTask(config).run(input);
 };
-Workflow9.prototype.contextBuilder = CreateWorkflow9(ContextBuilderTask);
+Workflow6.prototype.contextBuilder = CreateWorkflow6(ContextBuilderTask);
 
 // src/task/DocumentEnricherTask.ts
 import { getChildren, hasChildren } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow12, Task as Task8, Workflow as Workflow12 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow9, Task as Task5, Workflow as Workflow9 } from "@workglow/task-graph";
 
 // src/task/TextNamedEntityRecognitionTask.ts
-import { CreateWorkflow as CreateWorkflow10, Workflow as Workflow10 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow7, Workflow as Workflow7 } from "@workglow/task-graph";
 var modelSchema6 = TypeModel("model:TextNamedEntityRecognitionTask");
 var TextNamedEntityRecognitionInputSchema = {
   type: "object",
@@ -2860,10 +2466,10 @@ class TextNamedEntityRecognitionTask extends AiTask {
 var textNamedEntityRecognition = (input, config) => {
   return new TextNamedEntityRecognitionTask(config).run(input);
 };
-Workflow10.prototype.textNamedEntityRecognition = CreateWorkflow10(TextNamedEntityRecognitionTask);
+Workflow7.prototype.textNamedEntityRecognition = CreateWorkflow7(TextNamedEntityRecognitionTask);
 
 // src/task/TextSummaryTask.ts
-import { CreateWorkflow as CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow8, Workflow as Workflow8 } from "@workglow/task-graph";
 var modelSchema7 = TypeModel("model:TextSummaryTask");
 var TextSummaryInputSchema = {
   type: "object",
@@ -2907,10 +2513,10 @@ class TextSummaryTask extends StreamingAiTask {
 var textSummary = async (input, config) => {
   return new TextSummaryTask(config).run(input);
 };
-Workflow11.prototype.textSummary = CreateWorkflow11(TextSummaryTask);
+Workflow8.prototype.textSummary = CreateWorkflow8(TextSummaryTask);
 
 // src/task/DocumentEnricherTask.ts
-var inputSchema7 = {
+var inputSchema4 = {
   type: "object",
   properties: {
     doc_id: {
@@ -2954,7 +2560,7 @@ var inputSchema7 = {
   required: [],
   additionalProperties: false
 };
-var outputSchema7 = {
+var outputSchema4 = {
   type: "object",
   properties: {
     doc_id: {
@@ -2981,17 +2587,17 @@ var outputSchema7 = {
   additionalProperties: false
 };
 
-class DocumentEnricherTask extends Task8 {
+class DocumentEnricherTask extends Task5 {
   static type = "DocumentEnricherTask";
   static category = "Document";
   static title = "Document Enricher";
   static description = "Enrich document nodes with summaries and entities";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema7;
+    return inputSchema4;
   }
   static outputSchema() {
-    return outputSchema7;
+    return outputSchema4;
   }
   async execute(input, context) {
     const {
@@ -3140,16 +2746,16 @@ class DocumentEnricherTask extends Task8 {
 var documentEnricher = (input, config) => {
   return new DocumentEnricherTask(config).run(input);
 };
-Workflow12.prototype.documentEnricher = CreateWorkflow12(DocumentEnricherTask);
+Workflow9.prototype.documentEnricher = CreateWorkflow9(DocumentEnricherTask);
 
 // src/task/DocumentUpsertTask.ts
-import { Document, TypeKnowledgeBase as TypeKnowledgeBase5 } from "@workglow/knowledge-base";
+import { Document, TypeKnowledgeBase as TypeKnowledgeBase3 } from "@workglow/knowledge-base";
 import { DocumentMetadataSchema } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow13, Task as Task9, Workflow as Workflow13 } from "@workglow/task-graph";
-var inputSchema8 = {
+import { CreateWorkflow as CreateWorkflow10, Task as Task6, Workflow as Workflow10 } from "@workglow/task-graph";
+var inputSchema5 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase5({
+    knowledgeBase: TypeKnowledgeBase3({
       title: "Knowledge Base",
       description: "The knowledge base instance to store the document in"
     }),
@@ -3177,7 +2783,7 @@ var inputSchema8 = {
   required: ["knowledgeBase", "doc_id", "documentTree"],
   additionalProperties: false
 };
-var outputSchema8 = {
+var outputSchema5 = {
   type: "object",
   properties: {
     doc_id: {
@@ -3190,17 +2796,17 @@ var outputSchema8 = {
   additionalProperties: false
 };
 
-class DocumentUpsertTask extends Task9 {
+class DocumentUpsertTask extends Task6 {
   static type = "DocumentUpsertTask";
   static category = "Vector Store";
   static title = "Add Document";
   static description = "Persist a parsed document tree to a knowledge base";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema8;
+    return inputSchema5;
   }
   static outputSchema() {
-    return outputSchema8;
+    return outputSchema5;
   }
   async execute(input, context) {
     const { knowledgeBase, doc_id, documentTree, title, metadata } = input;
@@ -3223,10 +2829,10 @@ class DocumentUpsertTask extends Task9 {
 var documentUpsert = (input, config) => {
   return new DocumentUpsertTask(config).run(input);
 };
-Workflow13.prototype.documentUpsert = CreateWorkflow13(DocumentUpsertTask);
+Workflow10.prototype.documentUpsert = CreateWorkflow10(DocumentUpsertTask);
 
 // src/task/DownloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow11, Workflow as Workflow11 } from "@workglow/task-graph";
 var modelSchema8 = TypeModel("model");
 var DownloadModelInputSchema = {
   type: "object",
@@ -3293,10 +2899,10 @@ class DownloadModelTask extends AiTask {
 var downloadModel = (input, config) => {
   return new DownloadModelTask(config).run(input);
 };
-Workflow14.prototype.downloadModel = CreateWorkflow14(DownloadModelTask);
+Workflow11.prototype.downloadModel = CreateWorkflow11(DownloadModelTask);
 
 // src/task/FaceDetectorTask.ts
-import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow12, Workflow as Workflow12 } from "@workglow/task-graph";
 var modelSchema9 = TypeModel("model:FaceDetectorTask");
 var TypeBoundingBox2 = {
   type: "object",
@@ -3424,10 +3030,10 @@ class FaceDetectorTask extends AiVisionTask {
 var faceDetector = (input, config) => {
   return new FaceDetectorTask(config).run(input);
 };
-Workflow15.prototype.faceDetector = CreateWorkflow15(FaceDetectorTask);
+Workflow12.prototype.faceDetector = CreateWorkflow12(FaceDetectorTask);
 
 // src/task/FaceLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow16, Workflow as Workflow16 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow13, Workflow as Workflow13 } from "@workglow/task-graph";
 var modelSchema10 = TypeModel("model:FaceLandmarkerTask");
 var TypeLandmark = {
   type: "object",
@@ -3586,10 +3192,10 @@ class FaceLandmarkerTask extends AiVisionTask {
 var faceLandmarker = (input, config) => {
   return new FaceLandmarkerTask(config).run(input);
 };
-Workflow16.prototype.faceLandmarker = CreateWorkflow16(FaceLandmarkerTask);
+Workflow13.prototype.faceLandmarker = CreateWorkflow13(FaceLandmarkerTask);
 
 // src/task/GestureRecognizerTask.ts
-import { CreateWorkflow as CreateWorkflow17, Workflow as Workflow17 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow14, Workflow as Workflow14 } from "@workglow/task-graph";
 var modelSchema11 = TypeModel("model:GestureRecognizerTask");
 var TypeLandmark2 = {
   type: "object",
@@ -3754,10 +3360,10 @@ class GestureRecognizerTask extends AiVisionTask {
 var gestureRecognizer = (input, config) => {
   return new GestureRecognizerTask(config).run(input);
 };
-Workflow17.prototype.gestureRecognizer = CreateWorkflow17(GestureRecognizerTask);
+Workflow14.prototype.gestureRecognizer = CreateWorkflow14(GestureRecognizerTask);
 
 // src/task/HandLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow18, Workflow as Workflow18 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow15, Workflow as Workflow15 } from "@workglow/task-graph";
 var modelSchema12 = TypeModel("model:HandLandmarkerTask");
 var TypeLandmark3 = {
   type: "object",
@@ -3899,22 +3505,22 @@ class HandLandmarkerTask extends AiVisionTask {
 var handLandmarker = (input, config) => {
   return new HandLandmarkerTask(config).run(input);
 };
-Workflow18.prototype.handLandmarker = CreateWorkflow18(HandLandmarkerTask);
+Workflow15.prototype.handLandmarker = CreateWorkflow15(HandLandmarkerTask);
 
 // src/task/HierarchicalChunkerTask.ts
 import {
-  ChunkRecordSchema as ChunkRecordSchema2,
+  ChunkRecordSchema,
   estimateTokens as estimateTokens2,
   getChildren as getChildren2,
   hasChildren as hasChildren2
 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow19, Task as Task10, Workflow as Workflow19 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow16, Task as Task7, Workflow as Workflow16 } from "@workglow/task-graph";
 import { uuid4 } from "@workglow/util";
 var modelSchema13 = TypeModel("model", {
   title: "Model",
   description: "Model to use for token counting"
 });
-var inputSchema9 = {
+var inputSchema6 = {
   type: "object",
   properties: {
     doc_id: {
@@ -3961,7 +3567,7 @@ var inputSchema9 = {
   required: ["doc_id", "documentTree"],
   additionalProperties: false
 };
-var outputSchema9 = {
+var outputSchema6 = {
   type: "object",
   properties: {
     doc_id: {
@@ -3971,7 +3577,7 @@ var outputSchema9 = {
     },
     chunks: {
       type: "array",
-      items: ChunkRecordSchema2(),
+      items: ChunkRecordSchema(),
       title: "Chunks",
       description: "Array of chunk records"
     },
@@ -3991,17 +3597,17 @@ var outputSchema9 = {
   additionalProperties: false
 };
 
-class HierarchicalChunkerTask extends Task10 {
+class HierarchicalChunkerTask extends Task7 {
   static type = "HierarchicalChunkerTask";
   static category = "Document";
   static title = "Hierarchical Chunker";
   static description = "Chunk documents hierarchically respecting token budgets";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema9;
+    return inputSchema6;
   }
   static outputSchema() {
-    return outputSchema9;
+    return outputSchema6;
   }
   async execute(input, context) {
     const {
@@ -4135,36 +3741,36 @@ class HierarchicalChunkerTask extends Task10 {
 var hierarchicalChunker = (input, config) => {
   return new HierarchicalChunkerTask(config).run(input);
 };
-Workflow19.prototype.hierarchicalChunker = CreateWorkflow19(HierarchicalChunkerTask);
+Workflow16.prototype.hierarchicalChunker = CreateWorkflow16(HierarchicalChunkerTask);
 
 // src/task/HierarchyJoinTask.ts
-import { ChunkRecordArraySchema, TypeKnowledgeBase as TypeKnowledgeBase6 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow20, Task as Task11, Workflow as Workflow20 } from "@workglow/task-graph";
-var inputSchema10 = {
+import { ChunkRecordArraySchema as ChunkRecordArraySchema2, TypeKnowledgeBase as TypeKnowledgeBase4 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow17, Task as Task8, Workflow as Workflow17 } from "@workglow/task-graph";
+var inputSchema7 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase6({
+    knowledgeBase: TypeKnowledgeBase4({
       title: "Knowledge Base",
       description: "The knowledge base to query for hierarchy"
     }),
+    metadata: ChunkRecordArraySchema2,
     chunks: {
       type: "array",
       items: { type: "string" },
       title: "Chunks",
-      description: "Retrieved text chunks"
+      description: "Retrieved text chunks (pass-through)"
     },
     chunk_ids: {
       type: "array",
       items: { type: "string" },
       title: "Chunk IDs",
-      description: "IDs of retrieved chunks"
+      description: "IDs of retrieved chunks (pass-through)"
     },
-    metadata: ChunkRecordArraySchema,
     scores: {
       type: "array",
       items: { type: "number" },
       title: "Scores",
-      description: "Similarity scores for each result"
+      description: "Similarity scores (pass-through)"
     },
     includeParentSummaries: {
       type: "boolean",
@@ -4179,74 +3785,72 @@ var inputSchema10 = {
       default: true
     }
   },
-  required: ["knowledgeBase", "chunks", "chunk_ids", "metadata", "scores"],
+  required: ["knowledgeBase", "metadata"],
   additionalProperties: false
 };
-var outputSchema10 = {
+var outputSchema7 = {
   type: "object",
   properties: {
+    metadata: ChunkRecordArraySchema2,
     chunks: {
       type: "array",
       items: { type: "string" },
       title: "Chunks",
-      description: "Retrieved text chunks"
+      description: "Retrieved text chunks (pass-through)"
     },
     chunk_ids: {
       type: "array",
       items: { type: "string" },
       title: "Chunk IDs",
-      description: "IDs of retrieved chunks"
+      description: "IDs of retrieved chunks (pass-through)"
     },
-    metadata: ChunkRecordArraySchema,
     scores: {
       type: "array",
       items: { type: "number" },
       title: "Scores",
-      description: "Similarity scores"
+      description: "Similarity scores (pass-through)"
     },
     count: {
       type: "number",
       title: "Count",
-      description: "Number of results"
+      description: "Number of enriched records"
     }
   },
-  required: ["chunks", "chunk_ids", "metadata", "scores", "count"],
+  required: ["metadata", "count"],
   additionalProperties: false
 };
 
-class HierarchyJoinTask extends Task11 {
+class HierarchyJoinTask extends Task8 {
   static type = "HierarchyJoinTask";
   static category = "RAG";
   static title = "Hierarchy Join";
-  static description = "Enrich search results with document hierarchy context";
+  static description = "Enrich retrieval metadata with document hierarchy context";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema10;
+    return inputSchema7;
   }
   static outputSchema() {
-    return outputSchema10;
+    return outputSchema7;
   }
   async execute(input, context) {
     const {
       knowledgeBase,
+      metadata,
       chunks,
       chunk_ids,
-      metadata,
       scores,
       includeParentSummaries = true,
       includeEntities = true
     } = input;
     const kb = knowledgeBase;
     const enrichedMetadata = [];
-    for (let i = 0;i < chunk_ids.length; i++) {
-      const chunkId = chunk_ids[i];
-      const originalMetadata = metadata[i];
+    for (const originalMetadata of metadata) {
       if (!originalMetadata) {
         enrichedMetadata.push({});
         continue;
       }
       const doc_id = originalMetadata.doc_id;
-      const leafNodeId = originalMetadata.leafNodeId;
+      const leafNodeId = originalMetadata.leafNodeId ?? originalMetadata.nodePath?.[originalMetadata.nodePath.length - 1];
       if (!doc_id || !leafNodeId) {
         enrichedMetadata.push(originalMetadata);
         continue;
@@ -4292,31 +3896,35 @@ class HierarchyJoinTask extends Task11 {
         }
         enrichedMetadata.push(enriched);
       } catch (error) {
-        console.error(`Failed to join hierarchy for chunk ${chunkId}:`, error);
+        console.error(`Failed to join hierarchy for chunk ${originalMetadata.chunkId}:`, error);
         enrichedMetadata.push(originalMetadata);
       }
     }
-    return {
-      chunks,
-      chunk_ids,
+    const output = {
       metadata: enrichedMetadata,
-      scores,
-      count: chunks.length
+      count: enrichedMetadata.length
     };
+    if (chunks !== undefined)
+      output.chunks = chunks;
+    if (chunk_ids !== undefined)
+      output.chunk_ids = chunk_ids;
+    if (scores !== undefined)
+      output.scores = scores;
+    return output;
   }
 }
 var hierarchyJoin = (input, config) => {
   return new HierarchyJoinTask(config).run(input);
 };
-Workflow20.prototype.hierarchyJoin = CreateWorkflow20(HierarchyJoinTask);
+Workflow17.prototype.hierarchyJoin = CreateWorkflow17(HierarchyJoinTask);
 
 // src/task/KbToDocumentsTask.ts
-import { TypeKnowledgeBase as TypeKnowledgeBase7 } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow21, Task as Task12, Workflow as Workflow21 } from "@workglow/task-graph";
-var inputSchema11 = {
+import { TypeKnowledgeBase as TypeKnowledgeBase5 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow18, Task as Task9, Workflow as Workflow18 } from "@workglow/task-graph";
+var inputSchema8 = {
   type: "object",
   properties: {
-    knowledgeBase: TypeKnowledgeBase7({
+    knowledgeBase: TypeKnowledgeBase5({
       title: "Knowledge Base",
       description: "The knowledge base instance to list documents from"
     }),
@@ -4330,7 +3938,7 @@ var inputSchema11 = {
   required: ["knowledgeBase"],
   additionalProperties: false
 };
-var outputSchema11 = {
+var outputSchema8 = {
   type: "object",
   properties: {
     doc_id: {
@@ -4356,17 +3964,17 @@ var outputSchema11 = {
   additionalProperties: false
 };
 
-class KbToDocumentsTask extends Task12 {
+class KbToDocumentsTask extends Task9 {
   static type = "KbToDocumentsTask";
   static category = "Vector Store";
   static title = "Knowledge Base to Documents";
   static description = "List documents from a knowledge base, optionally filtering to only those that need embedding";
   static cacheable = false;
   static inputSchema() {
-    return inputSchema11;
+    return inputSchema8;
   }
   static outputSchema() {
-    return outputSchema11;
+    return outputSchema8;
   }
   async execute(input, context) {
     const { knowledgeBase, onlyStale = true } = input;
@@ -4397,10 +4005,10 @@ class KbToDocumentsTask extends Task12 {
 var kbToDocuments = (input, config) => {
   return new KbToDocumentsTask(config).run(input);
 };
-Workflow21.prototype.kbToDocuments = CreateWorkflow21(KbToDocumentsTask);
+Workflow18.prototype.kbToDocuments = CreateWorkflow18(KbToDocumentsTask);
 
 // src/task/ImageClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow19, Workflow as Workflow19 } from "@workglow/task-graph";
 var modelSchema14 = TypeModel("model:ImageClassificationTask");
 var ImageClassificationInputSchema = {
   type: "object",
@@ -4460,12 +4068,12 @@ class ImageClassificationTask extends AiVisionTask {
 var imageClassification = (input, config) => {
   return new ImageClassificationTask(config).run(input);
 };
-Workflow22.prototype.imageClassification = CreateWorkflow22(ImageClassificationTask);
+Workflow19.prototype.imageClassification = CreateWorkflow19(ImageClassificationTask);
 
 // src/task/ImageEmbeddingTask.ts
-import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow20, Workflow as Workflow20 } from "@workglow/task-graph";
 import {
-  TypedArraySchema as TypedArraySchema7
+  TypedArraySchema as TypedArraySchema4
 } from "@workglow/util/schema";
 var modelSchema15 = TypeModel("model:ImageEmbeddingTask");
 var ImageEmbeddingInputSchema = {
@@ -4480,7 +4088,7 @@ var ImageEmbeddingInputSchema = {
 var ImageEmbeddingOutputSchema = {
   type: "object",
   properties: {
-    vector: TypeSingleOrArray(TypedArraySchema7({
+    vector: TypeSingleOrArray(TypedArraySchema4({
       title: "Embedding",
       description: "The image embedding vector"
     }))
@@ -4504,10 +4112,10 @@ class ImageEmbeddingTask extends AiVisionTask {
 var imageEmbedding = (input, config) => {
   return new ImageEmbeddingTask(config).run(input);
 };
-Workflow23.prototype.imageEmbedding = CreateWorkflow23(ImageEmbeddingTask);
+Workflow20.prototype.imageEmbedding = CreateWorkflow20(ImageEmbeddingTask);
 
 // src/task/ImageSegmentationTask.ts
-import { CreateWorkflow as CreateWorkflow24, Workflow as Workflow24 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow21, Workflow as Workflow21 } from "@workglow/task-graph";
 var modelSchema16 = TypeModel("model:ImageSegmentationTask");
 var ImageSegmentationInputSchema = {
   type: "object",
@@ -4592,10 +4200,10 @@ class ImageSegmentationTask extends AiVisionTask {
 var imageSegmentation = (input, config) => {
   return new ImageSegmentationTask(config).run(input);
 };
-Workflow24.prototype.imageSegmentation = CreateWorkflow24(ImageSegmentationTask);
+Workflow21.prototype.imageSegmentation = CreateWorkflow21(ImageSegmentationTask);
 
 // src/task/ImageToTextTask.ts
-import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow22, Workflow as Workflow22 } from "@workglow/task-graph";
 var modelSchema17 = TypeModel("model:ImageToTextTask");
 var generatedTextSchema = {
   type: "string",
@@ -4647,10 +4255,10 @@ class ImageToTextTask extends AiVisionTask {
 var imageToText = (input, config) => {
   return new ImageToTextTask(config).run(input);
 };
-Workflow25.prototype.imageToText = CreateWorkflow25(ImageToTextTask);
+Workflow22.prototype.imageToText = CreateWorkflow22(ImageToTextTask);
 
 // src/task/ModelInfoTask.ts
-import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow23, Workflow as Workflow23 } from "@workglow/task-graph";
 var modelSchema18 = TypeModel("model");
 var ModelInfoInputSchema = {
   type: "object",
@@ -4726,10 +4334,10 @@ class ModelInfoTask extends AiTask {
 var modelInfo = (input, config) => {
   return new ModelInfoTask(config).run(input);
 };
-Workflow26.prototype.modelInfo = CreateWorkflow26(ModelInfoTask);
+Workflow23.prototype.modelInfo = CreateWorkflow23(ModelInfoTask);
 
 // src/task/ModelSearchTask.ts
-import { CreateWorkflow as CreateWorkflow27, Task as Task13, Workflow as Workflow27 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow24, Task as Task10, Workflow as Workflow24 } from "@workglow/task-graph";
 var ModelSearchInputSchema = {
   type: "object",
   properties: {
@@ -4794,7 +4402,7 @@ var ModelSearchOutputSchema = {
   additionalProperties: false
 };
 
-class ModelSearchTask extends Task13 {
+class ModelSearchTask extends Task10 {
   static type = "ModelSearchTask";
   static category = "AI Model";
   static title = "Model Search";
@@ -4820,10 +4428,10 @@ class ModelSearchTask extends Task13 {
 var modelSearch = (input, config) => {
   return new ModelSearchTask(config).run(input);
 };
-Workflow27.prototype.modelSearch = CreateWorkflow27(ModelSearchTask);
+Workflow24.prototype.modelSearch = CreateWorkflow24(ModelSearchTask);
 
 // src/task/ObjectDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow28, Workflow as Workflow28 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow25, Workflow as Workflow25 } from "@workglow/task-graph";
 var modelSchema19 = TypeModel("model:ObjectDetectionTask");
 var detectionSchema = {
   type: "object",
@@ -4903,10 +4511,10 @@ class ObjectDetectionTask extends AiVisionTask {
 var objectDetection = (input, config) => {
   return new ObjectDetectionTask(config).run(input);
 };
-Workflow28.prototype.objectDetection = CreateWorkflow28(ObjectDetectionTask);
+Workflow25.prototype.objectDetection = CreateWorkflow25(ObjectDetectionTask);
 
 // src/task/PoseLandmarkerTask.ts
-import { CreateWorkflow as CreateWorkflow29, Workflow as Workflow29 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow26, Workflow as Workflow26 } from "@workglow/task-graph";
 var modelSchema20 = TypeModel("model:PoseLandmarkerTask");
 var TypePoseLandmark = {
   type: "object",
@@ -5065,17 +4673,15 @@ class PoseLandmarkerTask extends AiVisionTask {
 var poseLandmarker = (input, config) => {
   return new PoseLandmarkerTask(config).run(input);
 };
-Workflow29.prototype.poseLandmarker = CreateWorkflow29(PoseLandmarkerTask);
+Workflow26.prototype.poseLandmarker = CreateWorkflow26(PoseLandmarkerTask);
 
 // src/task/QueryExpanderTask.ts
-import { CreateWorkflow as CreateWorkflow30, Task as Task14, Workflow as Workflow30 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow27, Task as Task11, Workflow as Workflow27 } from "@workglow/task-graph";
 var QueryExpansionMethod = {
   MULTI_QUERY: "multi-query",
-  HYDE: "hyde",
-  SYNONYMS: "synonyms",
-  PARAPHRASE: "paraphrase"
+  SYNONYMS: "synonyms"
 };
-var inputSchema12 = {
+var inputSchema9 = {
   type: "object",
   properties: {
     query: {
@@ -5097,17 +4703,12 @@ var inputSchema12 = {
       minimum: 1,
       maximum: 10,
       default: 3
-    },
-    model: {
-      type: "string",
-      title: "Model",
-      description: "LLM model to use for expansion (for HyDE and paraphrase methods)"
     }
   },
   required: ["query"],
   additionalProperties: false
 };
-var outputSchema12 = {
+var outputSchema9 = {
   type: "object",
   properties: {
     query: {
@@ -5136,31 +4737,25 @@ var outputSchema12 = {
   additionalProperties: false
 };
 
-class QueryExpanderTask extends Task14 {
+class QueryExpanderTask extends Task11 {
   static type = "QueryExpanderTask";
   static category = "RAG";
   static title = "Query Expander";
   static description = "Expand queries to improve retrieval coverage";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema12;
+    return inputSchema9;
   }
   static outputSchema() {
-    return outputSchema12;
+    return outputSchema9;
   }
   async execute(input, context) {
     const { query, method = QueryExpansionMethod.MULTI_QUERY, numVariations = 3 } = input;
     let queries;
     switch (method) {
-      case QueryExpansionMethod.HYDE:
-        queries = this.hydeExpansion(query, numVariations);
-        break;
       case QueryExpansionMethod.SYNONYMS:
         queries = this.synonymExpansion(query, numVariations);
         break;
-      case QueryExpansionMethod.PARAPHRASE:
-        queries = this.paraphraseExpansion(query, numVariations);
-        break;
       case QueryExpansionMethod.MULTI_QUERY:
       default:
         queries = this.multiQueryExpansion(query, numVariations);
@@ -5198,174 +4793,64 @@ class QueryExpanderTask extends Task14 {
     if (!query.toLowerCase().startsWith("explain")) {
       variations.push(`Explain ${query.toLowerCase()}`);
     }
-    for (let i = 0;i < Math.min(numVariations - 1, variations.length); i++) {
-      if (variations[i] && !queries.includes(variations[i])) {
-        queries.push(variations[i]);
-      }
-    }
-    return queries;
-  }
-  hydeExpansion(query, numVariations) {
-    const queries = [query];
-    const templates = [
-      `The answer to "${query}" is that`,
-      `Regarding ${query}, it is important to note that`,
-      `${query} can be explained by the fact that`,
-      `In response to ${query}, one should consider that`
-    ];
-    for (let i = 0;i < Math.min(numVariations - 1, templates.length); i++) {
-      queries.push(templates[i]);
-    }
-    return queries;
-  }
-  synonymExpansion(query, numVariations) {
-    const queries = [query];
-    const synonyms = {
-      find: ["locate", "discover", "search for"],
-      create: ["make", "build", "generate"],
-      delete: ["remove", "erase", "eliminate"],
-      update: ["modify", "change", "edit"],
-      show: ["display", "present", "reveal"],
-      explain: ["describe", "clarify", "elaborate"],
-      help: ["assist", "aid", "support"],
-      problem: ["issue", "challenge", "difficulty"],
-      solution: ["answer", "resolution", "fix"],
-      method: ["approach", "technique", "way"]
-    };
-    const words = query.toLowerCase().split(/\s+/);
-    let variationsGenerated = 0;
-    for (const [word, syns] of Object.entries(synonyms)) {
-      if (variationsGenerated >= numVariations - 1)
-        break;
-      const wordIndex = words.indexOf(word);
-      if (wordIndex !== -1) {
-        for (const syn of syns) {
-          if (variationsGenerated >= numVariations - 1)
-            break;
-          const newWords = [...words];
-          newWords[wordIndex] = syn;
-          const newQuery = newWords.join(" ");
-          const capitalizedQuery = this.preserveCapitalization(query, newQuery);
-          if (!queries.includes(capitalizedQuery)) {
-            queries.push(capitalizedQuery);
-            variationsGenerated++;
-          }
-        }
-      }
-    }
-    return queries;
-  }
-  paraphraseExpansion(query, numVariations) {
-    const queries = [query];
-    const paraphrases = [];
-    paraphrases.push(`I need information about ${query.toLowerCase()}`);
-    paraphrases.push(`Can you help me understand ${query.toLowerCase()}`);
-    paraphrases.push(`I'm looking for details on ${query.toLowerCase()}`);
-    for (let i = 0;i < Math.min(numVariations - 1, paraphrases.length); i++) {
-      if (!queries.includes(paraphrases[i])) {
-        queries.push(paraphrases[i]);
-      }
-    }
-    return queries;
-  }
-  preserveCapitalization(original, modified) {
-    if (original[0] === original[0].toUpperCase()) {
-      return modified.charAt(0).toUpperCase() + modified.slice(1);
-    }
-    return modified;
-  }
-}
-var queryExpander = (input, config) => {
-  return new QueryExpanderTask(config).run(input);
-};
-Workflow30.prototype.queryExpander = CreateWorkflow30(QueryExpanderTask);
-
-// src/task/RerankerTask.ts
-import { CreateWorkflow as CreateWorkflow32, Task as Task15, Workflow as Workflow32 } from "@workglow/task-graph";
-
-// src/task/TextClassificationTask.ts
-import { CreateWorkflow as CreateWorkflow31, Workflow as Workflow31 } from "@workglow/task-graph";
-var modelSchema21 = TypeModel("model:TextClassificationTask");
-var TextClassificationInputSchema = {
-  type: "object",
-  properties: {
-    text: {
-      type: "string",
-      title: "Text",
-      description: "The text to classify"
-    },
-    candidateLabels: {
-      type: "array",
-      items: {
-        type: "string"
-      },
-      title: "Candidate Labels",
-      description: "List of candidate labels (optional, if provided uses zero-shot classification)",
-      "x-ui-group": "Configuration"
-    },
-    maxCategories: {
-      type: "number",
-      minimum: 1,
-      maximum: 1000,
-      default: 5,
-      title: "Max Categories",
-      description: "The maximum number of categories to return",
-      "x-ui-group": "Configuration"
-    },
-    model: modelSchema21
-  },
-  required: ["text", "model"],
-  additionalProperties: false
-};
-var TextClassificationOutputSchema = {
-  type: "object",
-  properties: {
-    categories: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          label: {
-            type: "string",
-            title: "Label",
-            description: "The name of the category"
-          },
-          score: {
-            type: "number",
-            title: "Score",
-            description: "The confidence score for this category"
+    for (let i = 0;i < Math.min(numVariations - 1, variations.length); i++) {
+      if (variations[i] && !queries.includes(variations[i])) {
+        queries.push(variations[i]);
+      }
+    }
+    return queries;
+  }
+  synonymExpansion(query, numVariations) {
+    const queries = [query];
+    const synonyms = {
+      find: ["locate", "discover", "search for"],
+      create: ["make", "build", "generate"],
+      delete: ["remove", "erase", "eliminate"],
+      update: ["modify", "change", "edit"],
+      show: ["display", "present", "reveal"],
+      explain: ["describe", "clarify", "elaborate"],
+      help: ["assist", "aid", "support"],
+      problem: ["issue", "challenge", "difficulty"],
+      solution: ["answer", "resolution", "fix"],
+      method: ["approach", "technique", "way"]
+    };
+    const words = query.toLowerCase().split(/\s+/);
+    let variationsGenerated = 0;
+    for (const [word, syns] of Object.entries(synonyms)) {
+      if (variationsGenerated >= numVariations - 1)
+        break;
+      const wordIndex = words.indexOf(word);
+      if (wordIndex !== -1) {
+        for (const syn of syns) {
+          if (variationsGenerated >= numVariations - 1)
+            break;
+          const newWords = [...words];
+          newWords[wordIndex] = syn;
+          const capitalizedQuery = this.preserveCapitalization(query, newWords.join(" "));
+          if (!queries.includes(capitalizedQuery)) {
+            queries.push(capitalizedQuery);
+            variationsGenerated++;
           }
-        },
-        required: ["label", "score"],
-        additionalProperties: false
-      },
-      title: "Categories",
-      description: "The classification categories with their scores"
+        }
+      }
     }
-  },
-  required: ["categories"],
-  additionalProperties: false
-};
-
-class TextClassificationTask extends AiTask {
-  static type = "TextClassificationTask";
-  static category = "AI Text Model";
-  static title = "Text Classifier";
-  static description = "Classifies text into categories using language models. Supports zero-shot classification when candidate labels are provided.";
-  static inputSchema() {
-    return TextClassificationInputSchema;
+    return queries;
   }
-  static outputSchema() {
-    return TextClassificationOutputSchema;
+  preserveCapitalization(original, modified) {
+    if (original[0] === original[0].toUpperCase()) {
+      return modified.charAt(0).toUpperCase() + modified.slice(1);
+    }
+    return modified;
   }
 }
-var textClassification = (input, config) => {
-  return new TextClassificationTask(config).run(input);
+var queryExpander = (input, config) => {
+  return new QueryExpanderTask(config).run(input);
 };
-Workflow31.prototype.textClassification = CreateWorkflow31(TextClassificationTask);
+Workflow27.prototype.queryExpander = CreateWorkflow27(QueryExpanderTask);
 
 // src/task/RerankerTask.ts
-var inputSchema13 = {
+import { CreateWorkflow as CreateWorkflow28, Task as Task12, Workflow as Workflow28 } from "@workglow/task-graph";
+var inputSchema10 = {
   type: "object",
   properties: {
     query: {
@@ -5403,20 +4888,16 @@ var inputSchema13 = {
     },
     method: {
       type: "string",
-      enum: ["cross-encoder", "reciprocal-rank-fusion", "simple"],
+      enum: ["reciprocal-rank-fusion", "simple"],
       title: "Reranking Method",
       description: "Method to use for reranking",
       default: "simple"
-    },
-    model: TypeModel("model:RerankerTask", {
-      title: "Reranker Model",
-      description: "Cross-encoder model to use for reranking"
-    })
+    }
   },
   required: ["query", "chunks"],
   additionalProperties: false
 };
-var outputSchema13 = {
+var outputSchema10 = {
   type: "object",
   properties: {
     chunks: {
@@ -5457,28 +4938,22 @@ var outputSchema13 = {
   additionalProperties: false
 };
 
-class RerankerTask extends Task15 {
+class RerankerTask extends Task12 {
   static type = "RerankerTask";
   static category = "RAG";
   static title = "Reranker";
   static description = "Rerank retrieved chunks to improve relevance";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema13;
+    return inputSchema10;
   }
   static outputSchema() {
-    return outputSchema13;
+    return outputSchema10;
   }
   async execute(input, context) {
-    const { query, chunks, scores = [], metadata = [], topK, method = "simple", model } = input;
+    const { query, chunks, scores = [], metadata = [], topK, method = "simple" } = input;
     let rankedItems;
     switch (method) {
-      case "cross-encoder":
-        if (!model) {
-          throw new Error("No cross-encoder model found. Please provide a model with format 'model:RerankerTask'.");
-        }
-        rankedItems = await this.crossEncoderRerank(query, chunks, scores, metadata, model, context);
-        break;
       case "reciprocal-rank-fusion":
         rankedItems = this.reciprocalRankFusion(chunks, scores, metadata);
         break;
@@ -5498,44 +4973,6 @@ class RerankerTask extends Task15 {
       count: rankedItems.length
     };
   }
-  async crossEncoderRerank(query, chunks, scores, metadata, model, context) {
-    if (chunks.length === 0) {
-      return [];
-    }
-    if (!model) {
-      throw new Error("No cross-encoder model found. Please provide a model or register a TextClassificationTask model.");
-    }
-    const items = await Promise.all(chunks.map(async (chunk, index) => {
-      const pairText = `${query} [SEP] ${chunk}`;
-      const task = context.own(new TextClassificationTask({ defaults: { model } }));
-      const result = await task.run({ text: pairText, maxCategories: 2 });
-      const crossScore = this.extractCrossEncoderScore(result.categories);
-      return {
-        chunk,
-        score: Number.isFinite(crossScore) ? crossScore : scores[index] || 0,
-        metadata: metadata[index],
-        originalIndex: index
-      };
-    }));
-    items.sort((a, b) => b.score - a.score);
-    return items;
-  }
-  extractCrossEncoderScore(categories) {
-    if (!categories || categories.length === 0) {
-      return 0;
-    }
-    const preferred = categories.find((category) => /^(label_1|positive|relevant|yes|true)$/i.test(category.label));
-    if (preferred) {
-      return preferred.score;
-    }
-    let best = categories[0].score;
-    for (let i = 1;i < categories.length; i++) {
-      if (categories[i].score > best) {
-        best = categories[i].score;
-      }
-    }
-    return best;
-  }
   simpleRerank(query, chunks, scores, metadata) {
     const queryLower = query.toLowerCase();
     const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 0);
@@ -5543,7 +4980,6 @@ class RerankerTask extends Task15 {
       const chunkLower = chunk.toLowerCase();
       const initialScore = scores[index] || 0;
       let keywordScore = 0;
-      let exactMatchBonus = 0;
       for (const word of queryWords) {
         const regex = new RegExp(word, "gi");
         const matches = chunkLower.match(regex);
@@ -5551,33 +4987,23 @@ class RerankerTask extends Task15 {
           keywordScore += matches.length;
         }
       }
-      if (chunkLower.includes(queryLower)) {
-        exactMatchBonus = 0.5;
-      }
+      const exactMatchBonus = chunkLower.includes(queryLower) ? 0.5 : 0;
       const normalizedKeywordScore = Math.min(keywordScore / (queryWords.length * 3), 1);
       const positionPenalty = Math.log(index + 1) / 10;
       const combinedScore = initialScore * 0.4 + normalizedKeywordScore * 0.4 + exactMatchBonus * 0.2 - positionPenalty;
-      return {
-        chunk,
-        score: combinedScore,
-        metadata: metadata[index],
-        originalIndex: index
-      };
+      return { chunk, score: combinedScore, metadata: metadata[index], originalIndex: index };
     });
     items.sort((a, b) => b.score - a.score);
     return items;
   }
   reciprocalRankFusion(chunks, scores, metadata) {
     const k = 60;
-    const items = chunks.map((chunk, index) => {
-      const rrfScore = 1 / (k + index + 1);
-      return {
-        chunk,
-        score: rrfScore,
-        metadata: metadata[index],
-        originalIndex: index
-      };
-    });
+    const items = chunks.map((chunk, index) => ({
+      chunk,
+      score: 1 / (k + index + 1),
+      metadata: metadata[index],
+      originalIndex: index
+    }));
     items.sort((a, b) => b.score - a.score);
     return items;
   }
@@ -5585,13 +5011,13 @@ class RerankerTask extends Task15 {
 var reranker = (input, config) => {
   return new RerankerTask(config).run(input);
 };
-Workflow32.prototype.reranker = CreateWorkflow32(RerankerTask);
+Workflow28.prototype.reranker = CreateWorkflow28(RerankerTask);
 
 // src/task/StructuralParserTask.ts
 import { StructuralParser } from "@workglow/knowledge-base";
-import { CreateWorkflow as CreateWorkflow33, Task as Task16, Workflow as Workflow33 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow29, Task as Task13, Workflow as Workflow29 } from "@workglow/task-graph";
 import { uuid4 as uuid42 } from "@workglow/util";
-var inputSchema14 = {
+var inputSchema11 = {
   type: "object",
   properties: {
     text: {
@@ -5625,7 +5051,7 @@ var inputSchema14 = {
   required: ["text", "title"],
   additionalProperties: false
 };
-var outputSchema14 = {
+var outputSchema11 = {
   type: "object",
   properties: {
     doc_id: {
@@ -5649,17 +5075,17 @@ var outputSchema14 = {
   additionalProperties: false
 };
 
-class StructuralParserTask extends Task16 {
+class StructuralParserTask extends Task13 {
   static type = "StructuralParserTask";
   static category = "Document";
   static title = "Structural Parser";
   static description = "Parse documents into hierarchical tree structure";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema14;
+    return inputSchema11;
   }
   static outputSchema() {
-    return outputSchema14;
+    return outputSchema11;
   }
   async execute(input, context) {
     const { text, title, format = "auto", sourceUri, doc_id: providedDocId } = input;
@@ -5692,16 +5118,16 @@ class StructuralParserTask extends Task16 {
 var structuralParser = (input, config) => {
   return new StructuralParserTask(config).run(input);
 };
-Workflow33.prototype.structuralParser = CreateWorkflow33(StructuralParserTask);
+Workflow29.prototype.structuralParser = CreateWorkflow29(StructuralParserTask);
 
 // src/task/StructuredGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow34, TaskConfigurationError as TaskConfigurationError4, TaskError, Workflow as Workflow34 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow30, TaskConfigurationError as TaskConfigurationError4, TaskError, Workflow as Workflow30 } from "@workglow/task-graph";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
-var modelSchema22 = TypeModel("model:StructuredGenerationTask");
+var modelSchema21 = TypeModel("model:StructuredGenerationTask");
 var StructuredGenerationInputSchema = {
   type: "object",
   properties: {
-    model: modelSchema22,
+    model: modelSchema21,
     prompt: {
       type: "string",
       title: "Prompt",
@@ -5869,17 +5295,18 @@ class StructuredGenerationTask extends StreamingAiTask {
 var structuredGeneration = (input, config) => {
   return new StructuredGenerationTask(config).run(input);
 };
-Workflow34.prototype.structuredGeneration = CreateWorkflow34(StructuredGenerationTask);
+Workflow30.prototype.structuredGeneration = CreateWorkflow30(StructuredGenerationTask);
 
 // src/task/TextChunkerTask.ts
-import { CreateWorkflow as CreateWorkflow35, Task as Task17, Workflow as Workflow35 } from "@workglow/task-graph";
+import { ChunkRecordArraySchema as ChunkRecordArraySchema3 } from "@workglow/knowledge-base";
+import { CreateWorkflow as CreateWorkflow31, Task as Task14, Workflow as Workflow31 } from "@workglow/task-graph";
 var ChunkingStrategy = {
   FIXED: "fixed",
   SENTENCE: "sentence",
   PARAGRAPH: "paragraph",
   SEMANTIC: "semantic"
 };
-var inputSchema15 = {
+var inputSchema12 = {
   type: "object",
   properties: {
     text: {
@@ -5887,6 +5314,11 @@ var inputSchema15 = {
       title: "Text",
       description: "The text to chunk"
     },
+    doc_id: {
+      type: "string",
+      title: "Document ID",
+      description: "Optional document ID stamped onto each chunk. When omitted, chunks are emitted without a doc_id and the output also has no doc_id."
+    },
     chunkSize: {
       type: "number",
       title: "Chunk Size",
@@ -5912,88 +5344,99 @@ var inputSchema15 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema15 = {
+var outputSchema12 = {
   type: "object",
   properties: {
-    chunks: {
+    doc_id: {
+      type: "string",
+      title: "Document ID",
+      description: "The document ID (only emitted when provided in input)"
+    },
+    chunks: ChunkRecordArraySchema3,
+    text: {
       type: "array",
       items: { type: "string" },
-      title: "Text Chunks",
-      description: "The chunked text segments"
+      title: "Texts",
+      description: "Chunk texts (for TextEmbeddingTask)"
     },
-    metadata: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          index: { type: "number" },
-          startChar: { type: "number" },
-          endChar: { type: "number" },
-          length: { type: "number" }
-        },
-        additionalProperties: false
-      },
-      title: "Chunk Metadata",
-      description: "Metadata for each chunk"
+    count: {
+      type: "number",
+      title: "Count",
+      description: "Number of chunks generated"
     }
   },
-  required: ["chunks", "metadata"],
+  required: ["chunks", "text", "count"],
   additionalProperties: false
 };
 
-class TextChunkerTask extends Task17 {
+class TextChunkerTask extends Task14 {
   static type = "TextChunkerTask";
   static category = "Document";
   static title = "Text Chunker";
   static description = "Splits text into chunks using various strategies (fixed, sentence, paragraph)";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema15;
+    return inputSchema12;
   }
   static outputSchema() {
-    return outputSchema15;
+    return outputSchema12;
   }
   async execute(input, context) {
-    const { text, chunkSize = 512, chunkOverlap = 50, strategy = ChunkingStrategy.FIXED } = input;
-    let chunks;
-    let metadata;
+    const {
+      text,
+      doc_id,
+      chunkSize = 512,
+      chunkOverlap = 50,
+      strategy = ChunkingStrategy.FIXED
+    } = input;
+    let rawChunks;
     switch (strategy) {
       case ChunkingStrategy.SENTENCE:
-        ({ chunks, metadata } = this.chunkBySentence(text, chunkSize, chunkOverlap));
+      case ChunkingStrategy.SEMANTIC:
+        rawChunks = this.chunkBySentence(text, chunkSize, chunkOverlap);
         break;
       case ChunkingStrategy.PARAGRAPH:
-        ({ chunks, metadata } = this.chunkByParagraph(text, chunkSize, chunkOverlap));
-        break;
-      case ChunkingStrategy.SEMANTIC:
-        ({ chunks, metadata } = this.chunkBySentence(text, chunkSize, chunkOverlap));
+        rawChunks = this.chunkByParagraph(text, chunkSize, chunkOverlap);
         break;
       case ChunkingStrategy.FIXED:
       default:
-        ({ chunks, metadata } = this.chunkFixed(text, chunkSize, chunkOverlap));
+        rawChunks = this.chunkFixed(text, chunkSize, chunkOverlap);
         break;
     }
-    return { chunks, metadata };
+    const nodePath = doc_id ? [doc_id] : [];
+    const chunks = rawChunks.map((raw, index) => ({
+      chunkId: doc_id ? `${doc_id}:${index}` : `chunk:${index}:${raw.startChar}`,
+      doc_id: doc_id ?? "",
+      text: raw.text,
+      nodePath,
+      depth: nodePath.length,
+      ...doc_id ? { leafNodeId: doc_id } : {},
+      index,
+      startChar: raw.startChar,
+      endChar: raw.endChar
+    }));
+    const output = {
+      chunks,
+      text: chunks.map((c) => c.text),
+      count: chunks.length
+    };
+    if (doc_id)
+      output.doc_id = doc_id;
+    return output;
   }
   chunkFixed(text, chunkSize, chunkOverlap) {
     const chunks = [];
-    const metadata = [];
     let startChar = 0;
-    let index = 0;
     while (startChar < text.length) {
       const endChar = Math.min(startChar + chunkSize, text.length);
-      const chunk = text.substring(startChar, endChar);
-      chunks.push(chunk);
-      metadata.push({
-        index,
+      chunks.push({
+        text: text.substring(startChar, endChar),
         startChar,
-        endChar,
-        length: chunk.length
+        endChar
       });
-      const step = Math.max(1, chunkSize - chunkOverlap);
-      startChar += step;
-      index++;
+      startChar += Math.max(1, chunkSize - chunkOverlap);
     }
-    return { chunks, metadata };
+    return chunks;
   }
   chunkBySentence(text, chunkSize, chunkOverlap) {
     const sentenceRegex = /[.!?]+[\s\n]+/g;
@@ -6002,8 +5445,7 @@ class TextChunkerTask extends Task17 {
     let lastIndex = 0;
     let match;
     while ((match = sentenceRegex.exec(text)) !== null) {
-      const sentence = text.substring(lastIndex, match.index + match[0].length);
-      sentences.push(sentence);
+      sentences.push(text.substring(lastIndex, match.index + match[0].length));
       sentenceStarts.push(lastIndex);
       lastIndex = match.index + match[0].length;
     }
@@ -6012,22 +5454,17 @@ class TextChunkerTask extends Task17 {
       sentenceStarts.push(lastIndex);
     }
     const chunks = [];
-    const metadata = [];
     let currentChunk = "";
     let currentStartChar = 0;
-    let index = 0;
     for (let i = 0;i < sentences.length; i++) {
       const sentence = sentences[i];
       const sentenceStart = sentenceStarts[i];
       if (currentChunk.length > 0 && currentChunk.length + sentence.length > chunkSize) {
-        chunks.push(currentChunk.trim());
-        metadata.push({
-          index,
+        chunks.push({
+          text: currentChunk.trim(),
           startChar: currentStartChar,
-          endChar: currentStartChar + currentChunk.length,
-          length: currentChunk.trim().length
+          endChar: currentStartChar + currentChunk.length
         });
-        index++;
         if (chunkOverlap > 0) {
           let overlapText = "";
           let j = i - 1;
@@ -6049,37 +5486,30 @@ class TextChunkerTask extends Task17 {
       }
     }
     if (currentChunk.length > 0) {
-      chunks.push(currentChunk.trim());
-      metadata.push({
-        index,
+      chunks.push({
+        text: currentChunk.trim(),
         startChar: currentStartChar,
-        endChar: currentStartChar + currentChunk.length,
-        length: currentChunk.trim().length
+        endChar: currentStartChar + currentChunk.length
       });
     }
-    return { chunks, metadata };
+    return chunks;
   }
   chunkByParagraph(text, chunkSize, chunkOverlap) {
     const paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim().length > 0);
     const chunks = [];
-    const metadata = [];
     let currentChunk = "";
     let currentStartChar = 0;
-    let index = 0;
     let charPosition = 0;
     for (let i = 0;i < paragraphs.length; i++) {
       const paragraph = paragraphs[i].trim();
       const paragraphStart = text.indexOf(paragraph, charPosition);
       charPosition = paragraphStart + paragraph.length;
       if (currentChunk.length > 0 && currentChunk.length + paragraph.length + 2 > chunkSize) {
-        chunks.push(currentChunk.trim());
-        metadata.push({
-          index,
+        chunks.push({
+          text: currentChunk.trim(),
           startChar: currentStartChar,
-          endChar: currentStartChar + currentChunk.length,
-          length: currentChunk.trim().length
+          endChar: currentStartChar + currentChunk.length
         });
-        index++;
         if (chunkOverlap > 0 && i > 0) {
           let overlapText = "";
           let j = i - 1;
@@ -6107,24 +5537,103 @@ class TextChunkerTask extends Task17 {
       }
     }
     if (currentChunk.length > 0) {
-      chunks.push(currentChunk.trim());
-      metadata.push({
-        index,
+      chunks.push({
+        text: currentChunk.trim(),
         startChar: currentStartChar,
-        endChar: currentStartChar + currentChunk.length,
-        length: currentChunk.trim().length
+        endChar: currentStartChar + currentChunk.length
       });
     }
-    return { chunks, metadata };
+    return chunks;
   }
 }
 var textChunker = (input, config) => {
   return new TextChunkerTask(config).run(input);
 };
-Workflow35.prototype.textChunker = CreateWorkflow35(TextChunkerTask);
+Workflow31.prototype.textChunker = CreateWorkflow31(TextChunkerTask);
+
+// src/task/TextClassificationTask.ts
+import { CreateWorkflow as CreateWorkflow32, Workflow as Workflow32 } from "@workglow/task-graph";
+var modelSchema22 = TypeModel("model:TextClassificationTask");
+var TextClassificationInputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "The text to classify"
+    },
+    candidateLabels: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      title: "Candidate Labels",
+      description: "List of candidate labels (optional, if provided uses zero-shot classification)",
+      "x-ui-group": "Configuration"
+    },
+    maxCategories: {
+      type: "number",
+      minimum: 1,
+      maximum: 1000,
+      default: 5,
+      title: "Max Categories",
+      description: "The maximum number of categories to return",
+      "x-ui-group": "Configuration"
+    },
+    model: modelSchema22
+  },
+  required: ["text", "model"],
+  additionalProperties: false
+};
+var TextClassificationOutputSchema = {
+  type: "object",
+  properties: {
+    categories: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          label: {
+            type: "string",
+            title: "Label",
+            description: "The name of the category"
+          },
+          score: {
+            type: "number",
+            title: "Score",
+            description: "The confidence score for this category"
+          }
+        },
+        required: ["label", "score"],
+        additionalProperties: false
+      },
+      title: "Categories",
+      description: "The classification categories with their scores"
+    }
+  },
+  required: ["categories"],
+  additionalProperties: false
+};
+
+class TextClassificationTask extends AiTask {
+  static type = "TextClassificationTask";
+  static category = "AI Text Model";
+  static title = "Text Classifier";
+  static description = "Classifies text into categories using language models. Supports zero-shot classification when candidate labels are provided.";
+  static inputSchema() {
+    return TextClassificationInputSchema;
+  }
+  static outputSchema() {
+    return TextClassificationOutputSchema;
+  }
+}
+var textClassification = (input, config) => {
+  return new TextClassificationTask(config).run(input);
+};
+Workflow32.prototype.textClassification = CreateWorkflow32(TextClassificationTask);
 
 // src/task/TextFillMaskTask.ts
-import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow33, Workflow as Workflow33 } from "@workglow/task-graph";
 var modelSchema23 = TypeModel("model:TextFillMaskTask");
 var TextFillMaskInputSchema = {
   type: "object",
@@ -6189,10 +5698,10 @@ class TextFillMaskTask extends AiTask {
 var textFillMask = (input, config) => {
   return new TextFillMaskTask(config).run(input);
 };
-Workflow36.prototype.textFillMask = CreateWorkflow36(TextFillMaskTask);
+Workflow33.prototype.textFillMask = CreateWorkflow33(TextFillMaskTask);
 
 // src/task/TextGenerationTask.ts
-import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow34, Workflow as Workflow34 } from "@workglow/task-graph";
 var generatedTextSchema2 = {
   type: "string",
   title: "Text",
@@ -6277,10 +5786,10 @@ class TextGenerationTask extends StreamingAiTask {
 var textGeneration = (input, config) => {
   return new TextGenerationTask(config).run(input);
 };
-Workflow37.prototype.textGeneration = CreateWorkflow37(TextGenerationTask);
+Workflow34.prototype.textGeneration = CreateWorkflow34(TextGenerationTask);
 
 // src/task/TextLanguageDetectionTask.ts
-import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow35, Workflow as Workflow35 } from "@workglow/task-graph";
 var modelSchema25 = TypeModel("model:TextLanguageDetectionTask");
 var TextLanguageDetectionInputSchema = {
   type: "object",
@@ -6348,10 +5857,10 @@ class TextLanguageDetectionTask extends AiTask {
 var textLanguageDetection = (input, config) => {
   return new TextLanguageDetectionTask(config).run(input);
 };
-Workflow38.prototype.textLanguageDetection = CreateWorkflow38(TextLanguageDetectionTask);
+Workflow35.prototype.textLanguageDetection = CreateWorkflow35(TextLanguageDetectionTask);
 
 // src/task/TextQuestionAnswerTask.ts
-import { CreateWorkflow as CreateWorkflow39, Workflow as Workflow39 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow36, Workflow as Workflow36 } from "@workglow/task-graph";
 var contextSchema = {
   type: "string",
   title: "Context",
@@ -6403,10 +5912,10 @@ class TextQuestionAnswerTask extends StreamingAiTask {
 var textQuestionAnswer = (input, config) => {
   return new TextQuestionAnswerTask(config).run(input);
 };
-Workflow39.prototype.textQuestionAnswer = CreateWorkflow39(TextQuestionAnswerTask);
+Workflow36.prototype.textQuestionAnswer = CreateWorkflow36(TextQuestionAnswerTask);
 
 // src/task/TextRewriterTask.ts
-import { CreateWorkflow as CreateWorkflow40, Workflow as Workflow40 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow37, Workflow as Workflow37 } from "@workglow/task-graph";
 var modelSchema27 = TypeModel("model:TextRewriterTask");
 var TextRewriterInputSchema = {
   type: "object",
@@ -6455,10 +5964,10 @@ class TextRewriterTask extends StreamingAiTask {
 var textRewriter = (input, config) => {
   return new TextRewriterTask(config).run(input);
 };
-Workflow40.prototype.textRewriter = CreateWorkflow40(TextRewriterTask);
+Workflow37.prototype.textRewriter = CreateWorkflow37(TextRewriterTask);
 
 // src/task/TextTranslationTask.ts
-import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow38, Workflow as Workflow38 } from "@workglow/task-graph";
 var modelSchema28 = TypeModel("model:TextTranslationTask");
 var translationTextSchema = {
   type: "string",
@@ -6521,10 +6030,10 @@ class TextTranslationTask extends StreamingAiTask {
 var textTranslation = (input, config) => {
   return new TextTranslationTask(config).run(input);
 };
-Workflow41.prototype.textTranslation = CreateWorkflow41(TextTranslationTask);
+Workflow38.prototype.textTranslation = CreateWorkflow38(TextTranslationTask);
 
 // src/task/ToolCallingTask.ts
-import { CreateWorkflow as CreateWorkflow42, getTaskConstructors, Workflow as Workflow42 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow39, getTaskConstructors, Workflow as Workflow39 } from "@workglow/task-graph";
 import { makeFingerprint } from "@workglow/util";
 function taskTypesToTools(taskNames, registry) {
   const constructors = getTaskConstructors(registry);
@@ -6756,16 +6265,16 @@ class ToolCallingTask extends StreamingAiTask {
 var toolCalling = (input, config) => {
   return new ToolCallingTask(config).run(input);
 };
-Workflow42.prototype.toolCalling = CreateWorkflow42(ToolCallingTask);
+Workflow39.prototype.toolCalling = CreateWorkflow39(ToolCallingTask);
 
 // src/task/TopicSegmenterTask.ts
-import { CreateWorkflow as CreateWorkflow43, Task as Task18, Workflow as Workflow43 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow40, Task as Task15, Workflow as Workflow40 } from "@workglow/task-graph";
 var SegmentationMethod = {
   HEURISTIC: "heuristic",
   EMBEDDING_SIMILARITY: "embedding-similarity",
   HYBRID: "hybrid"
 };
-var inputSchema16 = {
+var inputSchema13 = {
   type: "object",
   properties: {
     text: {
@@ -6806,7 +6315,7 @@ var inputSchema16 = {
   required: ["text"],
   additionalProperties: false
 };
-var outputSchema16 = {
+var outputSchema13 = {
   type: "object",
   properties: {
     segments: {
@@ -6834,7 +6343,7 @@ var outputSchema16 = {
   additionalProperties: false
 };
 
-class TopicSegmenterTask extends Task18 {
+class TopicSegmenterTask extends Task15 {
   static type = "TopicSegmenterTask";
   static category = "Document";
   static title = "Topic Segmenter";
@@ -6842,10 +6351,10 @@ class TopicSegmenterTask extends Task18 {
   static cacheable = true;
   static EMBEDDING_DIMENSIONS = 256;
   static inputSchema() {
-    return inputSchema16;
+    return inputSchema13;
   }
   static outputSchema() {
-    return outputSchema16;
+    return outputSchema13;
   }
   async execute(input, context) {
     const {
@@ -7039,10 +6548,10 @@ class TopicSegmenterTask extends Task18 {
 var topicSegmenter = (input, config) => {
   return new TopicSegmenterTask(config).run(input);
 };
-Workflow43.prototype.topicSegmenter = CreateWorkflow43(TopicSegmenterTask);
+Workflow40.prototype.topicSegmenter = CreateWorkflow40(TopicSegmenterTask);
 
 // src/task/UnloadModelTask.ts
-import { CreateWorkflow as CreateWorkflow44, Workflow as Workflow44 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow41, Workflow as Workflow41 } from "@workglow/task-graph";
 var modelSchema30 = TypeModel("model");
 var UnloadModelInputSchema = {
   type: "object",
@@ -7077,27 +6586,27 @@ class UnloadModelTask extends AiTask {
 var unloadModel = (input, config) => {
   return new UnloadModelTask(config).run(input);
 };
-Workflow44.prototype.unloadModel = CreateWorkflow44(UnloadModelTask);
+Workflow41.prototype.unloadModel = CreateWorkflow41(UnloadModelTask);
 
 // src/task/VectorQuantizeTask.ts
-import { CreateWorkflow as CreateWorkflow45, Task as Task19, Workflow as Workflow45 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow42, Task as Task16, Workflow as Workflow42 } from "@workglow/task-graph";
 import {
   normalizeNumberArray,
   TensorType,
-  TypedArraySchema as TypedArraySchema8
+  TypedArraySchema as TypedArraySchema5
 } from "@workglow/util/schema";
-var inputSchema17 = {
+var inputSchema14 = {
   type: "object",
   properties: {
     vector: {
       anyOf: [
-        TypedArraySchema8({
+        TypedArraySchema5({
           title: "Vector",
           description: "The vector to quantize"
         }),
         {
           type: "array",
-          items: TypedArraySchema8({
+          items: TypedArraySchema5({
             title: "Vector",
             description: "Vector to quantize"
           })
@@ -7123,18 +6632,18 @@ var inputSchema17 = {
   required: ["vector", "targetType"],
   additionalProperties: false
 };
-var outputSchema17 = {
+var outputSchema14 = {
   type: "object",
   properties: {
     vector: {
       anyOf: [
-        TypedArraySchema8({
+        TypedArraySchema5({
           title: "Quantized Vector",
           description: "The quantized vector"
         }),
         {
           type: "array",
-          items: TypedArraySchema8({
+          items: TypedArraySchema5({
             title: "Quantized Vector",
             description: "Quantized vector"
           })
@@ -7160,19 +6669,22 @@ var outputSchema17 = {
   additionalProperties: false
 };
 
-class VectorQuantizeTask extends Task19 {
+class VectorQuantizeTask extends Task16 {
   static type = "VectorQuantizeTask";
   static category = "Vector";
   static title = "Quantize";
   static description = "Quantize vectors to reduce storage and improve performance";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema17;
+    return inputSchema14;
   }
   static outputSchema() {
-    return outputSchema17;
+    return outputSchema14;
+  }
+  async execute(input) {
+    return this.executePreview(input);
   }
-  async executeReactive(input) {
+  async executePreview(input) {
     const { vector, targetType, normalize = true } = input;
     const isArray = Array.isArray(vector);
     const vectors = isArray ? vector : [vector];
@@ -7260,15 +6772,15 @@ class VectorQuantizeTask extends Task19 {
 var vectorQuantize = (input, config) => {
   return new VectorQuantizeTask(config).run(input);
 };
-Workflow45.prototype.vectorQuantize = CreateWorkflow45(VectorQuantizeTask);
+Workflow42.prototype.vectorQuantize = CreateWorkflow42(VectorQuantizeTask);
 
 // src/task/VectorSimilarityTask.ts
-import { CreateWorkflow as CreateWorkflow46, GraphAsTask, Workflow as Workflow46 } from "@workglow/task-graph";
+import { CreateWorkflow as CreateWorkflow43, GraphAsTask, Workflow as Workflow43 } from "@workglow/task-graph";
 import {
   cosineSimilarity,
   hammingSimilarity,
   jaccardSimilarity,
-  TypedArraySchema as TypedArraySchema9
+  TypedArraySchema as TypedArraySchema6
 } from "@workglow/util/schema";
 var SimilarityFn = {
   COSINE: "cosine",
@@ -7283,13 +6795,13 @@ var similarityFunctions = {
 var SimilarityInputSchema = {
   type: "object",
   properties: {
-    query: TypedArraySchema9({
+    query: TypedArraySchema6({
       title: "Query",
       description: "Query vector to compare against"
     }),
     vectors: {
       type: "array",
-      items: TypedArraySchema9({
+      items: TypedArraySchema6({
         title: "Input",
         description: "Array of vectors to compare against the query"
       })
@@ -7317,7 +6829,7 @@ var SimilarityOutputSchema = {
   properties: {
     output: {
       type: "array",
-      items: TypedArraySchema9({
+      items: TypedArraySchema6({
         title: "Output",
         description: "Ranked output vectors"
       })
@@ -7347,7 +6859,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];
@@ -7369,7 +6889,7 @@ class VectorSimilarityTask extends GraphAsTask {
 var similarity = (input, config) => {
   return new VectorSimilarityTask(config).run(input);
 };
-Workflow46.prototype.similarity = CreateWorkflow46(VectorSimilarityTask);
+Workflow43.prototype.similarity = CreateWorkflow43(VectorSimilarityTask);
 // src/task/MessageConversion.ts
 function getInputMessages(input) {
   const messages = input.messages;
@@ -7523,14 +7043,11 @@ var registerAiTasks = () => {
   const tasks = [
     AiChatTask,
     BackgroundRemovalTask,
-    ChunkToVectorTask,
     CountTokensTask,
     ContextBuilderTask,
     DocumentEnricherTask,
     DocumentUpsertTask,
     ChunkRetrievalTask,
-    ChunkVectorHybridSearchTask,
-    ChunkVectorSearchTask,
     ChunkVectorUpsertTask,
     DownloadModelTask,
     FaceDetectorTask,
@@ -7573,7 +7090,6 @@ var registerAiTasks = () => {
   return tasks;
 };
 export {
-  vectorStoreSearch,
   vectorQuantize,
   unloadModel,
   topicSegmenter,
@@ -7615,7 +7131,6 @@ export {
   imageSegmentation,
   imageEmbedding,
   imageClassification,
-  hybridSearch,
   hierarchyJoin,
   hierarchicalChunker,
   handLandmarker,
@@ -7631,7 +7146,6 @@ export {
   countTokens,
   contextBuilder,
   chunkVectorUpsert,
-  chunkToVector,
   chunkRetrieval,
   buildToolDescription,
   backgroundRemoval,
@@ -7750,9 +7264,6 @@ export {
   ContentBlockSchema,
   ChunkingStrategy,
   ChunkVectorUpsertTask,
-  ChunkVectorSearchTask,
-  ChunkVectorHybridSearchTask,
-  ChunkToVectorTask,
   ChunkRetrievalTask,
   ChatMessageSchema,
   BackgroundRemovalTask,
@@ -7767,4 +7278,4 @@ export {
   AiChatInputSchema
 };
 
-//# debugId=3CD3867D0171540164756E2164756E21
+//# debugId=4A65F3B2D404BCCD64756E2164756E21