@workglow/ai 0.0.84 → 0.0.86

package/dist/task/RerankerTask.d.ts

@@ -0,0 +1,209 @@
+/**
+ * @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 query: {
+            readonly type: "string";
+            readonly title: "Query";
+            readonly description: "The query to rerank results against";
+        };
+        readonly chunks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "Text Chunks";
+            readonly description: "Retrieved text chunks to rerank";
+        };
+        readonly scores: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+            readonly title: "Initial Scores";
+            readonly description: "Initial retrieval scores (optional)";
+        };
+        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 topK: {
+            readonly type: "number";
+            readonly title: "Top K";
+            readonly description: "Number of top results to return after reranking";
+            readonly minimum: 1;
+        };
+        readonly method: {
+            readonly type: "string";
+            readonly enum: readonly ["cross-encoder", "reciprocal-rank-fusion", "simple"];
+            readonly title: "Reranking Method";
+            readonly description: "Method to use for reranking";
+            readonly default: "simple";
+        };
+        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 required: readonly ["query", "chunks"];
+    readonly additionalProperties: false;
+};
+declare const outputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly chunks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly title: "Reranked Chunks";
+            readonly description: "Chunks reordered by relevance";
+        };
+        readonly scores: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+            readonly title: "Reranked Scores";
+            readonly description: "New relevance scores";
+        };
+        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 reranked chunks";
+        };
+        readonly originalIndices: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+            };
+            readonly title: "Original Indices";
+            readonly description: "Original indices of reranked chunks";
+        };
+        readonly count: {
+            readonly type: "number";
+            readonly title: "Count";
+            readonly description: "Number of results returned";
+        };
+    };
+    readonly required: readonly ["chunks", "scores", "originalIndices", "count"];
+    readonly additionalProperties: false;
+};
+export type RerankerTaskInput = FromSchema<typeof inputSchema>;
+export type RerankerTaskOutput = FromSchema<typeof outputSchema>;
+/**
+ * Task for reranking retrieved chunks to improve relevance.
+ * Supports multiple reranking methods including cross-encoder models.
+ *
+ * Note: Cross-encoder reranking requires a model to be loaded.
+ * For now, this implements simple heuristic-based reranking.
+ */
+export declare class RerankerTask extends Task<RerankerTaskInput, RerankerTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    private resolvedCrossEncoderModel?;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: RerankerTaskInput, context: IExecuteContext): Promise<RerankerTaskOutput>;
+    private crossEncoderRerank;
+    private extractCrossEncoderScore;
+    /**
+     * Simple heuristic-based reranking using keyword matching and position
+     */
+    private simpleRerank;
+    /**
+     * Reciprocal Rank Fusion for combining multiple rankings
+     * Useful when you have multiple retrieval methods
+     */
+    private reciprocalRankFusion;
+}
+export declare const reranker: (input: RerankerTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    metadata?: {
+        [x: string]: unknown;
+    }[] | undefined;
+    chunks: string[];
+    scores: number[];
+    count: number;
+    originalIndices: number[];
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        reranker: CreateWorkflow<RerankerTaskInput, RerankerTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=RerankerTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RerankerTask.d.ts","sourceRoot":"","sources":["../../src/task/RerankerTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCiB,CAAC;AAEpC,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAC/D,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AASjE;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,IAAI,CAAC,iBAAiB,EAAE,kBAAkB,EAAE,kBAAkB,CAAC;IAC/F,OAAc,IAAI,SAAkB;IACpC,OAAc,QAAQ,SAAS;IAC/B,OAAc,KAAK,SAAc;IACjC,OAAc,WAAW,SAAkD;IAC3E,OAAc,SAAS,UAAQ;IAC/B,OAAO,CAAC,yBAAyB,CAAC,CAAgB;WAEpC,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,OAAO,CAAC,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;YA4ChF,kBAAkB;IAuChC,OAAO,CAAC,wBAAwB;IAqBhC;;OAEG;IACH,OAAO,CAAC,YAAY;IAuDpB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;CAqB7B;AAED,eAAO,MAAM,QAAQ,GAAI,OAAO,iBAAiB,EAAE,SAAS,kBAAkB;;;;;;;;EAE7E,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,QAAQ,EAAE,cAAc,CAAC,iBAAiB,EAAE,kBAAkB,EAAE,kBAAkB,CAAC,CAAC;KACrF;CACF"}

package/dist/task/StructuralParserTask.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @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 text: {
+            readonly type: "string";
+            readonly title: "Text";
+            readonly description: "The text content to parse";
+        };
+        readonly title: {
+            readonly type: "string";
+            readonly title: "Title";
+            readonly description: "Document title";
+        };
+        readonly format: {
+            readonly type: "string";
+            readonly enum: readonly ["markdown", "text", "auto"];
+            readonly title: "Format";
+            readonly description: "Document format (auto-detects if not specified)";
+            readonly default: "auto";
+        };
+        readonly sourceUri: {
+            readonly type: "string";
+            readonly title: "Source URI";
+            readonly description: "Source identifier for document ID generation";
+        };
+        readonly doc_id: {
+            readonly type: "string";
+            readonly title: "Document ID";
+            readonly description: "Pre-generated document ID (optional)";
+        };
+    };
+    readonly required: readonly ["text", "title"];
+    readonly additionalProperties: false;
+};
+declare const outputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly doc_id: {
+            readonly type: "string";
+            readonly title: "Document ID";
+            readonly description: "Generated or provided document ID";
+        };
+        readonly documentTree: {
+            readonly title: "Document Tree";
+            readonly description: "Parsed hierarchical document tree";
+        };
+        readonly nodeCount: {
+            readonly type: "number";
+            readonly title: "Node Count";
+            readonly description: "Total number of nodes in the tree";
+        };
+    };
+    readonly required: readonly ["doc_id", "documentTree", "nodeCount"];
+    readonly additionalProperties: false;
+};
+export type StructuralParserTaskInput = FromSchema<typeof inputSchema>;
+export type StructuralParserTaskOutput = FromSchema<typeof outputSchema>;
+/**
+ * Task for parsing documents into hierarchical tree structure
+ * Supports markdown and plain text with automatic format detection
+ */
+export declare class StructuralParserTask extends Task<StructuralParserTaskInput, StructuralParserTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: StructuralParserTaskInput, context: IExecuteContext): Promise<StructuralParserTaskOutput>;
+    private countNodes;
+}
+export declare const structuralParser: (input: StructuralParserTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    doc_id: string;
+    documentTree: unknown;
+    nodeCount: number;
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        structuralParser: CreateWorkflow<StructuralParserTaskInput, StructuralParserTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=StructuralParserTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StructuralParserTask.d.ts","sourceRoot":"","sources":["../../src/task/StructuralParserTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,IAAI,EAEL,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,UAAU,EAAS,MAAM,gBAAgB,CAAC;AAEnE,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;CAoBiB,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,SAAsD;IAC/E,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;IA2BtC,OAAO,CAAC,UAAU;CASnB;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"}

package/dist/task/TextChunkerTask.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @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";
+export declare const ChunkingStrategy: {
+    readonly FIXED: "fixed";
+    readonly SENTENCE: "sentence";
+    readonly PARAGRAPH: "paragraph";
+    readonly SEMANTIC: "semantic";
+};
+export type ChunkingStrategy = (typeof ChunkingStrategy)[keyof typeof ChunkingStrategy];
+declare const inputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly text: {
+            readonly type: "string";
+            readonly title: "Text";
+            readonly description: "The text to chunk";
+        };
+        readonly chunkSize: {
+            readonly type: "number";
+            readonly title: "Chunk Size";
+            readonly description: "Maximum size of each chunk in characters";
+            readonly minimum: 1;
+            readonly default: 512;
+        };
+        readonly chunkOverlap: {
+            readonly type: "number";
+            readonly title: "Chunk Overlap";
+            readonly description: "Number of characters to overlap between chunks";
+            readonly minimum: 0;
+            readonly default: 50;
+        };
+        readonly strategy: {
+            readonly type: "string";
+            readonly enum: ("fixed" | "sentence" | "paragraph" | "semantic")[];
+            readonly title: "Chunking Strategy";
+            readonly description: "Strategy to use for chunking text";
+            readonly default: "fixed";
+        };
+    };
+    readonly required: readonly ["text"];
+    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: "The chunked text segments";
+        };
+        readonly metadata: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly index: {
+                        readonly type: "number";
+                    };
+                    readonly startChar: {
+                        readonly type: "number";
+                    };
+                    readonly endChar: {
+                        readonly type: "number";
+                    };
+                    readonly length: {
+                        readonly type: "number";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly title: "Chunk Metadata";
+            readonly description: "Metadata for each chunk";
+        };
+    };
+    readonly required: readonly ["chunks", "metadata"];
+    readonly additionalProperties: false;
+};
+export type TextChunkerTaskInput = FromSchema<typeof inputSchema>;
+export type TextChunkerTaskOutput = FromSchema<typeof outputSchema>;
+/**
+ * Task for chunking text into smaller segments with configurable strategies.
+ * Supports fixed-size, sentence-based, paragraph-based, and semantic chunking.
+ */
+export declare class TextChunkerTask extends Task<TextChunkerTaskInput, TextChunkerTaskOutput, JobQueueTaskConfig> {
+    static type: string;
+    static category: string;
+    static title: string;
+    static description: string;
+    static cacheable: boolean;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    execute(input: TextChunkerTaskInput, context: IExecuteContext): Promise<TextChunkerTaskOutput>;
+    /**
+     * Fixed-size chunking with overlap
+     */
+    private chunkFixed;
+    /**
+     * Sentence-based chunking that respects sentence boundaries
+     */
+    private chunkBySentence;
+    /**
+     * Paragraph-based chunking that respects paragraph boundaries
+     */
+    private chunkByParagraph;
+}
+export declare const textChunker: (input: TextChunkerTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    metadata: {
+        length?: number | undefined;
+        index?: number | undefined;
+        startChar?: number | undefined;
+        endChar?: number | undefined;
+    }[];
+    chunks: string[];
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        textChunker: CreateWorkflow<TextChunkerTaskInput, TextChunkerTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export {};
+//# sourceMappingURL=TextChunkerTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextChunkerTask.d.ts","sourceRoot":"","sources":["../../src/task/TextChunkerTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,IAAI,EAEL,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5D,eAAO,MAAM,gBAAgB;;;;;CAKnB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAExF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCkB,CAAC;AAEpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BiB,CAAC;AAEpC,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AASpE;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,IAAI,CACvC,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,CACnB;IACC,OAAc,IAAI,SAAqB;IACvC,OAAc,QAAQ,SAAc;IACpC,OAAc,KAAK,SAAkB;IACrC,OAAc,WAAW,SACyD;IAClF,OAAc,SAAS,UAAQ;WAEjB,WAAW,IAAI,cAAc;WAI7B,YAAY,IAAI,cAAc;IAItC,OAAO,CACX,KAAK,EAAE,oBAAoB,EAC3B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,qBAAqB,CAAC;IA2BjC;;OAEG;IACH,OAAO,CAAC,UAAU;IA8BlB;;OAEG;IACH,OAAO,CAAC,eAAe;IAoFvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAoEzB;AAED,eAAO,MAAM,WAAW,GAAI,OAAO,oBAAoB,EAAE,SAAS,kBAAkB;;;;;;;;EAEnF,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,WAAW,EAAE,cAAc,CAAC,oBAAoB,EAAE,qBAAqB,EAAE,kBAAkB,CAAC,CAAC;KAC9F;CACF"}

package/dist/task/TextClassificationTask.d.ts

@@ -6,27 +6,13 @@
 import { CreateWorkflow, JobQueueTaskConfig } from "@workglow/task-graph";
 import { DataPortSchema, FromSchema } from "@workglow/util";
 import { AiTask } from "./base/AiTask";
-import { DeReplicateFromSchema } from "./base/AiTaskSchemas";
 export declare const TextClassificationInputSchema: {
     readonly type: "object";
     readonly properties: {
         readonly text: {
-            readonly "x-replicate": true;
-            readonly format?: string | undefined;
-            readonly oneOf: readonly [{
-                type: "string";
-                title: string;
-                description: string;
-            }, {
-                readonly type: "array";
-                readonly items: {
-                    type: "string";
-                    title: string;
-                    description: string;
-                };
-            }];
-            readonly title: string | undefined;
-            readonly description: string | undefined;
+            readonly type: "string";
+            readonly title: "Text";
+            readonly description: "The text to classify";
         };
         readonly candidateLabels: {
             readonly type: "array";
@@ -47,110 +33,53 @@ export declare const TextClassificationInputSchema: {
             readonly "x-ui-group": "Configuration";
         };
         readonly model: {
-            readonly "x-replicate": true;
-            readonly format?: string | undefined;
             readonly oneOf: readonly [{
-                readonly oneOf: readonly [{
-                    readonly title: "Model";
-                    readonly description: `The model ${string}`;
-                } & {
-                    readonly format: import(".").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;
-                } & {
-                    readonly format: import(".").TypeModelSemantic;
-                }];
+                readonly title: "Model";
+                readonly description: `The model ${string}`;
             } & {
                 readonly format: import(".").TypeModelSemantic;
+                readonly type: "string";
             }, {
-                readonly type: "array";
-                readonly items: {
-                    readonly oneOf: readonly [{
-                        readonly title: "Model";
-                        readonly description: `The model ${string}`;
-                    } & {
-                        readonly format: import(".").TypeModelSemantic;
+                readonly type: "object";
+                readonly properties: {
+                    readonly model_id: {
                         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 tasks: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
                         };
-                        readonly required: readonly ["provider", "provider_config"];
-                        readonly format: "model";
-                        readonly additionalProperties: false;
-                    } & {
-                        readonly format: import(".").TypeModelSemantic;
-                    }];
-                } & {
-                    readonly format: import(".").TypeModelSemantic;
+                        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;
+            } & {
+                readonly format: import(".").TypeModelSemantic;
             }];
-            readonly title: string | undefined;
-            readonly description: string | undefined;
+        } & {
+            readonly format: import(".").TypeModelSemantic;
         };
     };
     readonly required: readonly ["text", "model"];
@@ -187,8 +116,6 @@ export declare const TextClassificationOutputSchema: {
 };
 export type TextClassificationTaskInput = FromSchema<typeof TextClassificationInputSchema>;
 export type TextClassificationTaskOutput = FromSchema<typeof TextClassificationOutputSchema>;
-export type TextClassificationTaskExecuteInput = DeReplicateFromSchema<typeof TextClassificationInputSchema>;
-export type TextClassificationTaskExecuteOutput = DeReplicateFromSchema<typeof TextClassificationOutputSchema>;
 /**
  * Classifies text into categories using language models.
  * Automatically selects between regular and zero-shot classification based on whether candidate labels are provided.

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

@@ -1 +1 @@
-{"version":3,"file":"TextClassificationTask.d.ts","sourceRoot":"","sources":["../../src/task/TextClassificationTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAA0B,MAAM,sBAAsB,CAAC;AAClG,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAiC,MAAM,sBAAsB,CAAC;AAI5F,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BP,CAAC;AAEpC,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BR,CAAC;AAEpC,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAC3F,MAAM,MAAM,4BAA4B,GAAG,UAAU,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAC7F,MAAM,MAAM,kCAAkC,GAAG,qBAAqB,CACpE,OAAO,6BAA6B,CACrC,CAAC;AACF,MAAM,MAAM,mCAAmC,GAAG,qBAAqB,CACrE,OAAO,8BAA8B,CACtC,CAAC;AAEF;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,MAAM,CAChD,2BAA2B,EAC3B,4BAA4B,CAC7B;IACC,OAAc,IAAI,SAA4B;IAC9C,OAAc,QAAQ,SAAmB;IACzC,OAAc,KAAK,SAAqB;IACxC,OAAc,WAAW,SACwG;WACnH,WAAW,IAAI,cAAc;WAG7B,YAAY,IAAI,cAAc;CAG7C;AAID;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,2BAA2B,EAClC,SAAS,kBAAkB;;;;;EAG5B,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,kBAAkB,EAAE,cAAc,CAChC,2BAA2B,EAC3B,4BAA4B,EAC5B,kBAAkB,CACnB,CAAC;KACH;CACF"}
+{"version":3,"file":"TextClassificationTask.d.ts","sourceRoot":"","sources":["../../src/task/TextClassificationTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAY,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAKvC,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BP,CAAC;AAEpC,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BR,CAAC;AAEpC,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAC3F,MAAM,MAAM,4BAA4B,GAAG,UAAU,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE7F;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,MAAM,CAChD,2BAA2B,EAC3B,4BAA4B,CAC7B;IACC,OAAc,IAAI,SAA4B;IAC9C,OAAc,QAAQ,SAAmB;IACzC,OAAc,KAAK,SAAqB;IACxC,OAAc,WAAW,SACwG;WACnH,WAAW,IAAI,cAAc;WAG7B,YAAY,IAAI,cAAc;CAG7C;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,2BAA2B,EAClC,SAAS,kBAAkB;;;;;EAG5B,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,kBAAkB,EAAE,cAAc,CAChC,2BAA2B,EAC3B,4BAA4B,EAC5B,kBAAkB,CACnB,CAAC;KACH;CACF"}