@workglow/ai 0.0.85 → 0.0.87

package/dist/task/ChunkVectorSearchTask.d.ts

@@ -0,0 +1,137 @@
+/**
+ * @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 query: {
+            readonly type: "array";
+            readonly format: "TypedArray";
+            readonly title: "Typed Array";
+            readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+        };
+        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 similarity score threshold (0-1)";
+            readonly minimum: 0;
+            readonly maximum: 1;
+            readonly default: 0;
+        };
+    };
+    readonly required: readonly ["dataset", "query"];
+    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: "IDs of matching vectors";
+        };
+        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: "Matching vector embeddings";
+        };
+        readonly metadata: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly title: "Metadata";
+                readonly description: "Metadata of matching vector";
+            };
+            readonly title: "Metadata";
+            readonly description: "Metadata of matching vectors";
+        };
+        readonly scores: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+            readonly title: "Scores";
+            readonly description: "Similarity scores for each result";
+        };
+        readonly count: {
+            readonly type: "number";
+            readonly title: "Count";
+            readonly description: "Number of results returned";
+        };
+    };
+    readonly required: readonly ["ids", "vectors", "metadata", "scores", "count"];
+    readonly additionalProperties: false;
+};
+export type VectorStoreSearchTaskInput = FromSchema<typeof inputSchema, TypedArraySchemaOptions>;
+export type VectorStoreSearchTaskOutput = FromSchema<typeof outputSchema, TypedArraySchemaOptions>;
+/**
+ * Task for searching similar vectors in a document chunk dataset.
+ * Returns top-K most similar vectors with their metadata and scores.
+ */
+export declare class ChunkVectorSearchTask extends Task<VectorStoreSearchTaskInput, VectorStoreSearchTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: VectorStoreSearchTaskInput, context: IExecuteContext): Promise<VectorStoreSearchTaskOutput>;
+}
+export declare const vectorStoreSearch: (input: VectorStoreSearchTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    metadata: {
+        [x: string]: unknown;
+    }[];
+    vectors: import("@workglow/util").TypedArray[];
+    ids: string[];
+    scores: number[];
+    count: number;
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        vectorStoreSearch: CreateWorkflow<VectorStoreSearchTaskInput, VectorStoreSearchTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=ChunkVectorSearchTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkVectorSearchTask.d.ts","sourceRoot":"","sources":["../../src/task/ChunkVectorSearchTask.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CiB,CAAC;AAEpC,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,OAAO,WAAW,EAAE,uBAAuB,CAAC,CAAC;AACjG,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAAC,OAAO,YAAY,EAAE,uBAAuB,CAAC,CAAC;AAEnG;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,IAAI,CAC7C,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,CACnB;IACC,OAAc,IAAI,SAA2B;IAC7C,OAAc,QAAQ,SAAkB;IACxC,OAAc,KAAK,SAAyB;IAC5C,OAAc,WAAW,SAA4D;IACrF,OAAc,SAAS,UAAQ;WAEjB,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,OAAO,CACX,KAAK,EAAE,0BAA0B,EACjC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,2BAA2B,CAAC;CAmBxC;AAED,eAAO,MAAM,iBAAiB,GAC5B,OAAO,0BAA0B,EACjC,SAAS,kBAAkB;;;;;;;;EAG5B,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,iBAAiB,EAAE,cAAc,CAC/B,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,CACnB,CAAC;KACH;CACF"}

package/dist/task/ChunkVectorUpsertTask.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @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 doc_id: {
+            readonly type: "string";
+            readonly title: "Document ID";
+            readonly description: "The document ID";
+        };
+        readonly vectors: {
+            readonly anyOf: readonly [{
+                readonly type: "array";
+                readonly format: "TypedArray";
+                readonly title: "Typed Array";
+                readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "array";
+                    readonly format: "TypedArray";
+                    readonly title: "Typed Array";
+                    readonly description: "A typed array (Float32Array, Int8Array, etc.)";
+                };
+            }];
+        };
+        readonly metadata: {
+            readonly anyOf: readonly [{
+                readonly type: "object";
+                readonly title: "Metadata";
+                readonly description: "Metadata associated with the vector";
+                readonly additionalProperties: true;
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly title: "Metadata";
+                    readonly description: "Metadata associated with the vector";
+                    readonly additionalProperties: true;
+                };
+            }];
+        };
+    };
+    readonly required: readonly ["dataset", "doc_id", "vectors", "metadata"];
+    readonly additionalProperties: false;
+};
+declare const outputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly count: {
+            readonly type: "number";
+            readonly title: "Count";
+            readonly description: "Number of vectors upserted";
+        };
+        readonly doc_id: {
+            readonly type: "string";
+            readonly title: "Document ID";
+            readonly description: "The document ID";
+        };
+        readonly chunk_ids: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "Chunk IDs";
+            readonly description: "Chunk IDs of upserted vectors";
+        };
+    };
+    readonly required: readonly ["count", "doc_id", "chunk_ids"];
+    readonly additionalProperties: false;
+};
+export type VectorStoreUpsertTaskInput = FromSchema<typeof inputSchema, TypedArraySchemaOptions>;
+export type VectorStoreUpsertTaskOutput = FromSchema<typeof outputSchema>;
+/**
+ * Task for upserting (insert or update) vectors into a vector repository.
+ * Supports both single and bulk operations.
+ */
+export declare class ChunkVectorUpsertTask extends Task<VectorStoreUpsertTaskInput, VectorStoreUpsertTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: VectorStoreUpsertTaskInput, context: IExecuteContext): Promise<VectorStoreUpsertTaskOutput>;
+}
+export declare const chunkVectorUpsert: (input: VectorStoreUpsertTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    doc_id: string;
+    chunk_ids: string[];
+    count: number;
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        chunkVectorUpsert: CreateWorkflow<VectorStoreUpsertTaskInput, VectorStoreUpsertTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=ChunkVectorUpsertTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkVectorUpsertTask.d.ts","sourceRoot":"","sources":["../../src/task/ChunkVectorUpsertTask.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;AAGxB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;CAsBiB,CAAC;AAEpC,MAAM,MAAM,0BAA0B,GAAG,UAAU,CACjD,OAAO,WAAW,EAClB,uBAAuB,CACxB,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AAE1E;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,IAAI,CAC7C,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,CACnB;IACC,OAAc,IAAI,SAA2B;IAC7C,OAAc,QAAQ,SAAkB;IACxC,OAAc,KAAK,SAAyB;IAC5C,OAAc,WAAW,SAAuE;IAChG,OAAc,SAAS,UAAS;WAElB,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,OAAO,CACX,KAAK,EAAE,0BAA0B,EACjC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,2BAA2B,CAAC;CAsDxC;AAED,eAAO,MAAM,iBAAiB,GAC5B,OAAO,0BAA0B,EACjC,SAAS,kBAAkB;;;;EAG5B,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,iBAAiB,EAAE,cAAc,CAC/B,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,CACnB,CAAC;KACH;CACF"}

package/dist/task/ContextBuilderTask.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CreateWorkflow, JobQueueTaskConfig, Task } from "@workglow/task-graph";
+import { DataPortSchema, FromSchema } from "@workglow/util";
+export declare const ContextFormat: {
+    readonly SIMPLE: "simple";
+    readonly NUMBERED: "numbered";
+    readonly XML: "xml";
+    readonly MARKDOWN: "markdown";
+    readonly JSON: "json";
+};
+export type ContextFormat = (typeof ContextFormat)[keyof typeof ContextFormat];
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly chunks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "Text Chunks";
+            readonly description: "Retrieved text chunks to format";
+        };
+        readonly metadata: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly title: "Metadata";
+                readonly description: "Metadata for each chunk";
+            };
+            readonly title: "Metadata";
+            readonly description: "Metadata for each chunk (optional)";
+        };
+        readonly scores: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+            readonly title: "Scores";
+            readonly description: "Relevance scores for each chunk (optional)";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly enum: ("simple" | "numbered" | "xml" | "markdown" | "json")[];
+            readonly title: "Format";
+            readonly description: "Format for the context output";
+            readonly default: "simple";
+        };
+        readonly maxLength: {
+            readonly type: "number";
+            readonly title: "Max Length";
+            readonly description: "Maximum length of context in characters (0 = unlimited)";
+            readonly minimum: 0;
+            readonly default: 0;
+        };
+        readonly includeMetadata: {
+            readonly type: "boolean";
+            readonly title: "Include Metadata";
+            readonly description: "Whether to include metadata in the context";
+            readonly default: false;
+        };
+        readonly separator: {
+            readonly type: "string";
+            readonly title: "Separator";
+            readonly description: "Separator between chunks";
+            readonly default: "\n\n";
+        };
+    };
+    readonly required: readonly ["chunks"];
+    readonly additionalProperties: false;
+};
+declare const outputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly context: {
+            readonly type: "string";
+            readonly title: "Context";
+            readonly description: "Formatted context string for LLM";
+        };
+        readonly chunksUsed: {
+            readonly type: "number";
+            readonly title: "Chunks Used";
+            readonly description: "Number of chunks included in context";
+        };
+        readonly totalLength: {
+            readonly type: "number";
+            readonly title: "Total Length";
+            readonly description: "Total length of context in characters";
+        };
+    };
+    readonly required: readonly ["context", "chunksUsed", "totalLength"];
+    readonly additionalProperties: false;
+};
+export type ContextBuilderTaskInput = FromSchema<typeof inputSchema>;
+export type ContextBuilderTaskOutput = FromSchema<typeof outputSchema>;
+/**
+ * Task for formatting retrieved chunks into context for LLM prompts.
+ * Supports various formatting styles and length constraints.
+ */
+export declare class ContextBuilderTask extends Task<ContextBuilderTaskInput, ContextBuilderTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    executeReactive(input: ContextBuilderTaskInput, output: ContextBuilderTaskOutput): Promise<ContextBuilderTaskOutput>;
+    private formatChunk;
+    private formatNumbered;
+    private formatXML;
+    private formatMarkdown;
+    private formatJSON;
+    private formatMetadataInline;
+    private escapeXML;
+}
+export declare const contextBuilder: (input: ContextBuilderTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    context: string;
+    chunksUsed: number;
+    totalLength: number;
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        contextBuilder: CreateWorkflow<ContextBuilderTaskInput, ContextBuilderTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=ContextBuilderTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContextBuilderTask.d.ts","sourceRoot":"","sources":["../../src/task/ContextBuilderTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,IAAI,EAAY,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5D,eAAO,MAAM,aAAa;;;;;;CAMhB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAE/E,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;CAqBiB,CAAC;AAEpC,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AACrE,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AAEvE;;;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,SAA0D;IACnF,OAAc,SAAS,UAAQ;WAEjB,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,eAAe,CACnB,KAAK,EAAE,uBAAuB,EAC9B,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,wBAAwB,CAAC;IAqDpC,OAAO,CAAC,WAAW;IAuBnB,OAAO,CAAC,cAAc;IAiBtB,OAAO,CAAC,SAAS;IA2BjB,OAAO,CAAC,cAAc;IAwBtB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,oBAAoB;IAa5B,OAAO,CAAC,SAAS;CAQlB;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/DocumentEnricherTask.d.ts

@@ -0,0 +1,232 @@
+/**
+ * @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 } 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 documentTree: {
+            readonly title: "Document Tree";
+            readonly description: "The hierarchical document tree to enrich";
+        };
+        readonly generateSummaries: {
+            readonly type: "boolean";
+            readonly title: "Generate Summaries";
+            readonly description: "Whether to generate summaries for sections";
+            readonly default: true;
+        };
+        readonly extractEntities: {
+            readonly type: "boolean";
+            readonly title: "Extract Entities";
+            readonly description: "Whether to extract named entities";
+            readonly default: true;
+        };
+        readonly summaryModel: {
+            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: true;
+            } & {
+                title: string;
+                description: string;
+            } & {
+                readonly format: import("./base/AiTaskSchemas").TypeModelSemantic;
+            }];
+        } & {
+            title: string;
+            description: string;
+        } & {
+            readonly format: import("./base/AiTaskSchemas").TypeModelSemantic;
+        };
+        readonly summaryThreshold: {
+            readonly type: "number";
+            readonly title: "Summary Threshold";
+            readonly description: "Minimum combined text length (node + children) to warrant generating a summary";
+            readonly default: 500;
+        };
+        readonly nerModel: {
+            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: true;
+            } & {
+                title: string;
+                description: string;
+            } & {
+                readonly format: import("./base/AiTaskSchemas").TypeModelSemantic;
+            }];
+        } & {
+            title: string;
+            description: string;
+        } & {
+            readonly format: import("./base/AiTaskSchemas").TypeModelSemantic;
+        };
+    };
+    readonly required: readonly [];
+    readonly additionalProperties: false;
+};
+declare const outputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly doc_id: {
+            readonly type: "string";
+            readonly title: "Document ID";
+            readonly description: "The document ID (passed through)";
+        };
+        readonly documentTree: {
+            readonly title: "Document Tree";
+            readonly description: "The enriched document tree";
+        };
+        readonly summaryCount: {
+            readonly type: "number";
+            readonly title: "Summary Count";
+            readonly description: "Number of summaries generated";
+        };
+        readonly entityCount: {
+            readonly type: "number";
+            readonly title: "Entity Count";
+            readonly description: "Number of entities extracted";
+        };
+    };
+    readonly required: readonly ["doc_id", "documentTree", "summaryCount", "entityCount"];
+    readonly additionalProperties: false;
+};
+export type DocumentEnricherTaskInput = FromSchema<typeof inputSchema>;
+export type DocumentEnricherTaskOutput = FromSchema<typeof outputSchema>;
+/**
+ * Task for enriching document nodes with summaries and entities
+ * Uses bottom-up propagation to roll up child information to parents
+ */
+export declare class DocumentEnricherTask extends Task<DocumentEnricherTaskInput, DocumentEnricherTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: DocumentEnricherTaskInput, context: IExecuteContext): Promise<DocumentEnricherTaskOutput>;
+    /**
+     * Enrich a node recursively (bottom-up)
+     */
+    private enrichNode;
+    /**
+     * Private method to summarize text using the TextSummaryTask
+     */
+    private summarize;
+    /**
+     * Generate summary for a node with children
+     */
+    private generateSummary;
+    /**
+     * Generate summary for a leaf node
+     */
+    private generateLeafSummary;
+    /**
+     * Extract and roll up entities from node and children
+     */
+    private extractEntities;
+}
+export declare const documentEnricher: (input: DocumentEnricherTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    doc_id: string;
+    documentTree: unknown;
+    summaryCount: number;
+    entityCount: number;
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        documentEnricher: CreateWorkflow<DocumentEnricherTaskInput, DocumentEnricherTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=DocumentEnricherTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentEnricherTask.d.ts","sourceRoot":"","sources":["../../src/task/DocumentEnricherTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EACL,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,IAAI,EAEL,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAM5D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;CAyBiB,CAAC;AAEpC,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AACvE,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AAEzE;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,IAAI,CAC5C,yBAAyB,EACzB,0BAA0B,EAC1B,kBAAkB,CACnB;IACC,OAAc,IAAI,SAA0B;IAC5C,OAAc,QAAQ,SAAc;IACpC,OAAc,KAAK,SAAuB;IAC1C,OAAc,WAAW,SAAuD;IAChF,OAAc,SAAS,UAAQ;WAEjB,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,OAAO,CACX,KAAK,EAAE,yBAAyB,EAChC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,0BAA0B,CAAC;IAkDtC;;OAEG;YACW,UAAU;IA6ExB;;OAEG;YACW,SAAS;IASvB;;OAEG;YACW,eAAe;IAgE7B;;OAEG;YACW,mBAAmB;IAoBjC;;OAEG;YACW,eAAe;CAqC9B;AAED,eAAO,MAAM,gBAAgB,GAAI,OAAO,yBAAyB,EAAE,SAAS,kBAAkB;;;;;EAE7F,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,gBAAgB,EAAE,cAAc,CAC9B,yBAAyB,EACzB,0BAA0B,EAC1B,kBAAkB,CACnB,CAAC;KACH;CACF"}