@workglow/ai 0.0.85 → 0.0.86

package/dist/task/ChunkRetrievalTask.d.ts

@@ -0,0 +1,243 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CreateWorkflow, IExecuteContext, JobQueueTaskConfig, Task } from "@workglow/task-graph";
+import { DataPortSchema, FromSchema, TypedArray, TypedArraySchemaOptions } from "@workglow/util";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly dataset: {
+            readonly title: "Document Chunk Dataset";
+            readonly description: "Dataset ID or instance for document chunk data storage";
+        } & {
+            title: string;
+            description: string;
+        } & {
+            readonly format: "dataset:document-chunk";
+            readonly anyOf: readonly [{
+                readonly type: "string";
+                readonly title: "Dataset ID";
+            }, {
+                readonly title: "Dataset Instance";
+                readonly additionalProperties: true;
+            }];
+        };
+        readonly query: {
+            readonly anyOf: readonly [{
+                readonly oneOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "array";
+                    readonly format: "TypedArray";
+                    readonly title: "Typed Array";
+                    readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+                }];
+                readonly title: "Query";
+                readonly description: "Query string or pre-computed query vector";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly type: "array";
+                        readonly format: "TypedArray";
+                        readonly title: "Typed Array";
+                        readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+                    }];
+                    readonly title: "Query";
+                    readonly description: "Query string or pre-computed query vector";
+                };
+            }];
+        };
+        readonly model: {
+            readonly oneOf: readonly [{
+                readonly title: "Model";
+                readonly description: `The model ${string}`;
+            } & {
+                title: string;
+                description: string;
+            } & {
+                readonly format: import("./base/AiTaskSchemas").TypeModelSemantic;
+                readonly type: "string";
+            }, {
+                readonly type: "object";
+                readonly properties: {
+                    readonly model_id: {
+                        readonly type: "string";
+                    };
+                    readonly tasks: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly "x-ui-editor": "multiselect";
+                    };
+                    readonly title: {
+                        readonly type: "string";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly "x-ui-editor": "textarea";
+                    };
+                    readonly provider: {
+                        readonly type: "string";
+                    };
+                    readonly provider_config: {
+                        readonly type: "object";
+                        readonly default: {};
+                    };
+                    readonly metadata: {
+                        readonly type: "object";
+                        readonly default: {};
+                        readonly "x-ui-hidden": true;
+                    };
+                };
+                readonly required: readonly ["provider", "provider_config"];
+                readonly format: "model";
+                readonly additionalProperties: false;
+            } & {
+                title: string;
+                description: string;
+            } & {
+                readonly format: import("./base/AiTaskSchemas").TypeModelSemantic;
+            }];
+        } & {
+            title: string;
+            description: string;
+        } & {
+            readonly format: import("./base/AiTaskSchemas").TypeModelSemantic;
+        };
+        readonly topK: {
+            readonly type: "number";
+            readonly title: "Top K";
+            readonly description: "Number of top results to return";
+            readonly minimum: 1;
+            readonly default: 5;
+        };
+        readonly filter: {
+            readonly type: "object";
+            readonly title: "Metadata Filter";
+            readonly description: "Filter results by metadata fields";
+        };
+        readonly scoreThreshold: {
+            readonly type: "number";
+            readonly title: "Score Threshold";
+            readonly description: "Minimum similarity score threshold (0-1)";
+            readonly minimum: 0;
+            readonly maximum: 1;
+            readonly default: 0;
+        };
+        readonly returnVectors: {
+            readonly type: "boolean";
+            readonly title: "Return Vectors";
+            readonly description: "Whether to return vector embeddings in results";
+            readonly default: false;
+        };
+    };
+    readonly required: readonly ["dataset", "query"];
+    readonly if: {
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly then: {
+        readonly required: readonly ["dataset", "query", "model"];
+    };
+    readonly else: {};
+    readonly additionalProperties: false;
+};
+declare const outputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly chunks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "Text Chunks";
+            readonly description: "Retrieved text chunks";
+        };
+        readonly chunk_ids: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "IDs";
+            readonly description: "IDs of retrieved chunks";
+        };
+        readonly metadata: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly title: "Metadata";
+                readonly description: "Metadata of retrieved chunk";
+            };
+            readonly title: "Metadata";
+            readonly description: "Metadata of retrieved chunks";
+        };
+        readonly scores: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+            readonly title: "Scores";
+            readonly description: "Similarity scores for each result";
+        };
+        readonly vectors: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "array";
+                readonly format: "TypedArray";
+                readonly title: "Typed Array";
+                readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+            };
+            readonly title: "Vectors";
+            readonly description: "Vector embeddings (if returnVectors is true)";
+        };
+        readonly count: {
+            readonly type: "number";
+            readonly title: "Count";
+            readonly description: "Number of results returned";
+        };
+    };
+    readonly required: readonly ["chunks", "chunk_ids", "metadata", "scores", "count"];
+    readonly additionalProperties: false;
+};
+export type ChunkRetrievalTaskInput = FromSchema<typeof inputSchema, TypedArraySchemaOptions>;
+export type ChunkRetrievalTaskOutput = FromSchema<typeof outputSchema, TypedArraySchemaOptions>;
+/**
+ * End-to-end retrieval task that combines embedding generation (if needed) and vector search.
+ * Simplifies the RAG pipeline by handling the full retrieval process.
+ */
+export declare class ChunkRetrievalTask extends Task<ChunkRetrievalTaskInput, ChunkRetrievalTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: ChunkRetrievalTaskInput, context: IExecuteContext): Promise<ChunkRetrievalTaskOutput>;
+}
+export declare const chunkRetrieval: (input: ChunkRetrievalTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    vectors?: TypedArray[] | undefined;
+    metadata: {
+        [x: string]: unknown;
+    }[];
+    chunks: string[];
+    scores: number[];
+    chunk_ids: string[];
+    count: number;
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        chunkRetrieval: CreateWorkflow<ChunkRetrievalTaskInput, ChunkRetrievalTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=ChunkRetrievalTask.d.ts.map

package/dist/task/ChunkRetrievalTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkRetrievalTask.d.ts","sourceRoot":"","sources":["../../src/task/ChunkRetrievalTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,IAAI,EAEL,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,UAAU,EAEV,UAAU,EAEV,uBAAuB,EACxB,MAAM,gBAAgB,CAAC;AAIxB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDiB,CAAC;AAEpC,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,WAAW,EAAE,uBAAuB,CAAC,CAAC;AAC9F,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,YAAY,EAAE,uBAAuB,CAAC,CAAC;AAEhG;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,IAAI,CAC1C,uBAAuB,EACvB,wBAAwB,EACxB,kBAAkB,CACnB;IACC,OAAc,IAAI,SAAwB;IAC1C,OAAc,QAAQ,SAAS;IAC/B,OAAc,KAAK,SAAqB;IACxC,OAAc,WAAW,SAAqE;IAC9F,OAAc,SAAS,UAAQ;WAEjB,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,OAAO,CACX,KAAK,EAAE,uBAAuB,EAC9B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,wBAAwB,CAAC;CA2ErC;AAED,eAAO,MAAM,cAAc,GAAI,OAAO,uBAAuB,EAAE,SAAS,kBAAkB;;;;;;;;;EAEzF,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,cAAc,EAAE,cAAc,CAC5B,uBAAuB,EACvB,wBAAwB,EACxB,kBAAkB,CACnB,CAAC;KACH;CACF"}

package/dist/task/ChunkToVectorTask.d.ts

@@ -0,0 +1,183 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CreateWorkflow, IExecuteContext, JobQueueTaskConfig, Task } from "@workglow/task-graph";
+import { DataPortSchema, FromSchema, TypedArraySchemaOptions } from "@workglow/util";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly doc_id: {
+            readonly type: "string";
+            readonly title: "Document ID";
+            readonly description: "The document ID";
+        };
+        readonly chunks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly chunkId: {
+                        readonly type: "string";
+                        readonly title: "Chunk ID";
+                        readonly description: "Unique identifier for this chunk";
+                    };
+                    readonly doc_id: {
+                        readonly type: "string";
+                        readonly title: "Document ID";
+                        readonly description: "ID of the parent document";
+                    };
+                    readonly text: {
+                        readonly type: "string";
+                        readonly title: "Text";
+                        readonly description: "Text content of the chunk";
+                    };
+                    readonly nodePath: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly title: "Node Path";
+                        readonly description: "Node IDs from root to leaf";
+                    };
+                    readonly depth: {
+                        readonly type: "integer";
+                        readonly title: "Depth";
+                        readonly description: "Depth in the document tree";
+                    };
+                    readonly enrichment: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly summary: {
+                                readonly type: "string";
+                                readonly title: "Summary";
+                                readonly description: "Summary of the chunk content";
+                            };
+                            readonly entities: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly text: {
+                                            readonly type: "string";
+                                            readonly title: "Text";
+                                            readonly description: "Entity text";
+                                        };
+                                        readonly type: {
+                                            readonly type: "string";
+                                            readonly title: "Type";
+                                            readonly description: "Entity type (e.g., PERSON, ORG, LOC)";
+                                        };
+                                        readonly score: {
+                                            readonly type: "number";
+                                            readonly title: "Score";
+                                            readonly description: "Confidence score";
+                                        };
+                                    };
+                                    readonly required: readonly ["text", "type", "score"];
+                                    readonly additionalProperties: false;
+                                };
+                                readonly title: "Entities";
+                                readonly description: "Named entities extracted from the chunk";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly required: readonly ["chunkId", "doc_id", "text", "nodePath", "depth"];
+                readonly additionalProperties: false;
+            };
+            readonly title: "Chunks";
+            readonly description: "Array of chunk nodes";
+        };
+        readonly vectors: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "array";
+                readonly format: "TypedArray";
+                readonly title: "Typed Array";
+                readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+            };
+            readonly title: "Vectors";
+            readonly description: "Embeddings from TextEmbeddingTask";
+        };
+    };
+    readonly required: readonly ["chunks", "vectors"];
+    readonly additionalProperties: false;
+};
+declare const outputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly ids: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "IDs";
+            readonly description: "Chunk IDs for vector store";
+        };
+        readonly vectors: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "array";
+                readonly format: "TypedArray";
+                readonly title: "Typed Array";
+                readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+            };
+            readonly title: "Vectors";
+            readonly description: "Vector embeddings";
+        };
+        readonly metadata: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly title: "Metadata";
+                readonly description: "Metadata for vector store";
+            };
+            readonly title: "Metadata";
+            readonly description: "Metadata for each vector";
+        };
+        readonly texts: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "Texts";
+            readonly description: "Chunk texts (for reference)";
+        };
+    };
+    readonly required: readonly ["ids", "vectors", "metadata", "texts"];
+    readonly additionalProperties: false;
+};
+export type ChunkToVectorTaskInput = FromSchema<typeof inputSchema, TypedArraySchemaOptions>;
+export type ChunkToVectorTaskOutput = FromSchema<typeof outputSchema, TypedArraySchemaOptions>;
+/**
+ * Task to transform chunk nodes and embeddings into vector store format
+ * Bridges HierarchicalChunker + TextEmbedding → VectorStoreUpsert
+ */
+export declare class ChunkToVectorTask extends Task<ChunkToVectorTaskInput, ChunkToVectorTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: ChunkToVectorTaskInput, context: IExecuteContext): Promise<ChunkToVectorTaskOutput>;
+}
+export declare const chunkToVector: (input: ChunkToVectorTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    metadata: {
+        [x: string]: unknown;
+    }[];
+    vectors: import("@workglow/util").TypedArray[];
+    ids: string[];
+    texts: string[];
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        chunkToVector: CreateWorkflow<ChunkToVectorTaskInput, ChunkToVectorTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=ChunkToVectorTask.d.ts.map

package/dist/task/ChunkToVectorTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkToVectorTask.d.ts","sourceRoot":"","sources":["../../src/task/ChunkToVectorTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,IAAI,EAEL,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,UAAU,EAEV,uBAAuB,EACxB,MAAM,gBAAgB,CAAC;AAExB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCiB,CAAC;AAEpC,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,WAAW,EAAE,uBAAuB,CAAC,CAAC;AAC7F,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,YAAY,EAAE,uBAAuB,CAAC,CAAC;AAE/F;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,IAAI,CACzC,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,CACnB;IACC,OAAc,IAAI,SAAuB;IACzC,OAAc,QAAQ,SAAc;IACpC,OAAc,KAAK,SAAqB;IACxC,OAAc,WAAW,SAA4D;IACrF,OAAc,SAAS,UAAQ;WAEjB,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,OAAO,CACX,KAAK,EAAE,sBAAsB,EAC7B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,uBAAuB,CAAC;CA0CpC;AAED,eAAO,MAAM,aAAa,GAAI,OAAO,sBAAsB,EAAE,SAAS,kBAAkB;;;;;;;EAEvF,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,aAAa,EAAE,cAAc,CAC3B,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,CACnB,CAAC;KACH;CACF"}

package/dist/task/ChunkVectorHybridSearchTask.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CreateWorkflow, IExecuteContext, JobQueueTaskConfig, Task } from "@workglow/task-graph";
+import { DataPortSchema, FromSchema, TypedArraySchemaOptions } from "@workglow/util";
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly dataset: {
+            readonly title: "Document Chunk Dataset";
+            readonly description: "Dataset ID or instance for document chunk data storage";
+        } & {
+            title: string;
+            description: string;
+        } & {
+            readonly format: "dataset:document-chunk";
+            readonly anyOf: readonly [{
+                readonly type: "string";
+                readonly title: "Dataset ID";
+            }, {
+                readonly title: "Dataset Instance";
+                readonly additionalProperties: true;
+            }];
+        };
+        readonly queryVector: {
+            readonly type: "array";
+            readonly format: "TypedArray";
+            readonly title: "Typed Array";
+            readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+        };
+        readonly queryText: {
+            readonly type: "string";
+            readonly title: "Query Text";
+            readonly description: "The query text for full-text search";
+        };
+        readonly topK: {
+            readonly type: "number";
+            readonly title: "Top K";
+            readonly description: "Number of top results to return";
+            readonly minimum: 1;
+            readonly default: 10;
+        };
+        readonly filter: {
+            readonly type: "object";
+            readonly title: "Metadata Filter";
+            readonly description: "Filter results by metadata fields";
+        };
+        readonly scoreThreshold: {
+            readonly type: "number";
+            readonly title: "Score Threshold";
+            readonly description: "Minimum combined score threshold (0-1)";
+            readonly minimum: 0;
+            readonly maximum: 1;
+            readonly default: 0;
+        };
+        readonly vectorWeight: {
+            readonly type: "number";
+            readonly title: "Vector Weight";
+            readonly description: "Weight for vector similarity (0-1), remainder goes to text relevance";
+            readonly minimum: 0;
+            readonly maximum: 1;
+            readonly default: 0.7;
+        };
+        readonly returnVectors: {
+            readonly type: "boolean";
+            readonly title: "Return Vectors";
+            readonly description: "Whether to return vector embeddings in results";
+            readonly default: false;
+        };
+    };
+    readonly required: readonly ["dataset", "queryVector", "queryText"];
+    readonly additionalProperties: false;
+};
+declare const outputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly chunks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "Text Chunks";
+            readonly description: "Retrieved text chunks";
+        };
+        readonly ids: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "IDs";
+            readonly description: "IDs of retrieved chunks";
+        };
+        readonly metadata: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly title: "Metadata";
+                readonly description: "Metadata of retrieved chunk";
+            };
+            readonly title: "Metadata";
+            readonly description: "Metadata of retrieved chunks";
+        };
+        readonly scores: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+            readonly title: "Scores";
+            readonly description: "Combined relevance scores for each result";
+        };
+        readonly vectors: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "array";
+                readonly format: "TypedArray";
+                readonly title: "Typed Array";
+                readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+            };
+            readonly title: "Vectors";
+            readonly description: "Vector embeddings (if returnVectors is true)";
+        };
+        readonly count: {
+            readonly type: "number";
+            readonly title: "Count";
+            readonly description: "Number of results returned";
+        };
+    };
+    readonly required: readonly ["chunks", "ids", "metadata", "scores", "count"];
+    readonly additionalProperties: false;
+};
+export type HybridSearchTaskInput = FromSchema<typeof inputSchema, TypedArraySchemaOptions>;
+export type HybridSearchTaskOutput = FromSchema<typeof outputSchema, TypedArraySchemaOptions>;
+/**
+ * Task for hybrid search combining vector similarity and full-text search.
+ * Requires a document chunk vector repository that supports hybridSearch (e.g., Postgres with pgvector).
+ *
+ * Hybrid search improves retrieval by combining:
+ * - Semantic similarity (vector search) - understands meaning
+ * - Keyword matching (full-text search) - finds exact terms
+ */
+export declare class ChunkVectorHybridSearchTask extends Task<HybridSearchTaskInput, HybridSearchTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: HybridSearchTaskInput, context: IExecuteContext): Promise<HybridSearchTaskOutput>;
+}
+export declare const hybridSearch: (input: HybridSearchTaskInput, config?: JobQueueTaskConfig) => Promise<HybridSearchTaskOutput>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        hybridSearch: CreateWorkflow<HybridSearchTaskInput, HybridSearchTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=ChunkVectorHybridSearchTask.d.ts.map

package/dist/task/ChunkVectorHybridSearchTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkVectorHybridSearchTask.d.ts","sourceRoot":"","sources":["../../src/task/ChunkVectorHybridSearchTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,IAAI,EAEL,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,UAAU,EAEV,uBAAuB,EACxB,MAAM,gBAAgB,CAAC;AAExB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDiB,CAAC;AAEpC,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,WAAW,EAAE,uBAAuB,CAAC,CAAC;AAC5F,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,YAAY,EAAE,uBAAuB,CAAC,CAAC;AAE9F;;;;;;;GAOG;AACH,qBAAa,2BAA4B,SAAQ,IAAI,CACnD,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,CACnB;IACC,OAAc,IAAI,SAAiC;IACnD,OAAc,QAAQ,SAAS;IAC/B,OAAc,KAAK,SAAmB;IACtC,OAAc,WAAW,SAA+D;IACxF,OAAc,SAAS,UAAQ;WAEjB,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,OAAO,CACX,KAAK,EAAE,qBAAqB,EAC5B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,sBAAsB,CAAC;CAqDnC;AAED,eAAO,MAAM,YAAY,GACvB,OAAO,qBAAqB,EAC5B,SAAS,kBAAkB,KAC1B,OAAO,CAAC,sBAAsB,CAEhC,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,YAAY,EAAE,cAAc,CAAC,qBAAqB,EAAE,sBAAsB,EAAE,kBAAkB,CAAC,CAAC;KACjG;CACF"}