@workglow/ai 0.0.52

package/dist/task/VectorSimilarityTask.d.ts

@@ -0,0 +1,334 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ArrayTask, CreateWorkflow, JobQueueTaskConfig } from "@workglow/task-graph";
+import { DataPortSchema, FromSchema } from "@workglow/util";
+import { TypedArray, TypedArraySchemaOptions } from "./base/AiTaskSchemas";
+export declare const SimilarityFn: {
+    readonly COSINE: "cosine";
+    readonly JACCARD: "jaccard";
+    readonly HAMMING: "hamming";
+};
+export type SimilarityFn = (typeof SimilarityFn)[keyof typeof SimilarityFn];
+declare const SimilarityInputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly query: {
+            readonly oneOf: readonly [{
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Float64";
+                };
+                readonly title: "Float64Array";
+                readonly description: "A 64-bit floating point array";
+                readonly format: "Float64Array";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Float32";
+                };
+                readonly title: "Float32Array";
+                readonly description: "A 32-bit floating point array";
+                readonly format: "Float32Array";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Int32";
+                };
+                readonly title: "Int32Array";
+                readonly description: "A 32-bit integer array";
+                readonly format: "Int32Array";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Int16";
+                };
+                readonly title: "Int16Array";
+                readonly description: "A 16-bit integer array";
+                readonly format: "Int16Array";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Int8";
+                };
+                readonly title: "Int8Array";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Uint8";
+                };
+                readonly title: "Uint8Array";
+                readonly description: "A 8-bit unsigned integer array";
+                readonly format: "Uint8Array";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Uint16";
+                };
+                readonly title: "Uint16Array";
+                readonly description: "A 16-bit unsigned integer array";
+                readonly format: "Uint16Array";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Uint32";
+                };
+                readonly title: "Uint32Array";
+                readonly description: "A 32-bit unsigned integer array";
+                readonly format: "Uint32Array";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly format: "Uint8Clamped";
+                };
+                readonly title: "Uint8ClampedArray";
+                readonly description: "A 8-bit unsigned integer array with values clamped to 0-255";
+                readonly format: "Uint8ClampedArray";
+            }];
+            readonly format: "TypedArray";
+        };
+        readonly input: {
+            readonly type: "array";
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Float64";
+                    };
+                    readonly title: "Float64Array";
+                    readonly description: "A 64-bit floating point array";
+                    readonly format: "Float64Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Float32";
+                    };
+                    readonly title: "Float32Array";
+                    readonly description: "A 32-bit floating point array";
+                    readonly format: "Float32Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Int32";
+                    };
+                    readonly title: "Int32Array";
+                    readonly description: "A 32-bit integer array";
+                    readonly format: "Int32Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Int16";
+                    };
+                    readonly title: "Int16Array";
+                    readonly description: "A 16-bit integer array";
+                    readonly format: "Int16Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Int8";
+                    };
+                    readonly title: "Int8Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Uint8";
+                    };
+                    readonly title: "Uint8Array";
+                    readonly description: "A 8-bit unsigned integer array";
+                    readonly format: "Uint8Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Uint16";
+                    };
+                    readonly title: "Uint16Array";
+                    readonly description: "A 16-bit unsigned integer array";
+                    readonly format: "Uint16Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Uint32";
+                    };
+                    readonly title: "Uint32Array";
+                    readonly description: "A 32-bit unsigned integer array";
+                    readonly format: "Uint32Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Uint8Clamped";
+                    };
+                    readonly title: "Uint8ClampedArray";
+                    readonly description: "A 8-bit unsigned integer array with values clamped to 0-255";
+                    readonly format: "Uint8ClampedArray";
+                }];
+                readonly format: "TypedArray";
+            };
+        };
+        readonly topK: {
+            readonly type: "number";
+            readonly title: "Top K";
+            readonly description: "Number of top results to return";
+            readonly minimum: 1;
+            readonly default: 10;
+        };
+        readonly similarity: {
+            readonly type: "string";
+            readonly enum: ("cosine" | "jaccard" | "hamming")[];
+            readonly title: "Similarity 𝑓";
+            readonly description: "Similarity function to use for comparisons";
+            readonly default: "cosine";
+        };
+    };
+    readonly required: readonly ["query", "input", "similarity"];
+    readonly additionalProperties: false;
+};
+declare const SimilarityOutputSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly output: {
+            readonly type: "array";
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Float64";
+                    };
+                    readonly title: "Float64Array";
+                    readonly description: "A 64-bit floating point array";
+                    readonly format: "Float64Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Float32";
+                    };
+                    readonly title: "Float32Array";
+                    readonly description: "A 32-bit floating point array";
+                    readonly format: "Float32Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Int32";
+                    };
+                    readonly title: "Int32Array";
+                    readonly description: "A 32-bit integer array";
+                    readonly format: "Int32Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Int16";
+                    };
+                    readonly title: "Int16Array";
+                    readonly description: "A 16-bit integer array";
+                    readonly format: "Int16Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Int8";
+                    };
+                    readonly title: "Int8Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Uint8";
+                    };
+                    readonly title: "Uint8Array";
+                    readonly description: "A 8-bit unsigned integer array";
+                    readonly format: "Uint8Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Uint16";
+                    };
+                    readonly title: "Uint16Array";
+                    readonly description: "A 16-bit unsigned integer array";
+                    readonly format: "Uint16Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Uint32";
+                    };
+                    readonly title: "Uint32Array";
+                    readonly description: "A 32-bit unsigned integer array";
+                    readonly format: "Uint32Array";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly format: "Uint8Clamped";
+                    };
+                    readonly title: "Uint8ClampedArray";
+                    readonly description: "A 8-bit unsigned integer array with values clamped to 0-255";
+                    readonly format: "Uint8ClampedArray";
+                }];
+                readonly format: "TypedArray";
+            };
+        };
+        readonly score: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly title: "Score";
+                readonly description: "Similarity scores for each output vector";
+            };
+        };
+    };
+    readonly required: readonly ["output", "score"];
+    readonly additionalProperties: false;
+};
+export type VectorSimilarityTaskInput = FromSchema<typeof SimilarityInputSchema, TypedArraySchemaOptions>;
+export type VectorSimilarityTaskOutput = FromSchema<typeof SimilarityOutputSchema, TypedArraySchemaOptions>;
+export declare class VectorSimilarityTask extends ArrayTask<VectorSimilarityTaskInput, VectorSimilarityTaskOutput, JobQueueTaskConfig> {
+    static readonly type = "VectorSimilarityTask";
+    static readonly category = "Analysis";
+    static readonly title = "Vector Similarity";
+    static description: string;
+    static readonly cacheable = true;
+    static inputSchema(): DataPortSchema;
+    static outputSchema(): DataPortSchema;
+    executeReactive({ query, input, similarity, topK }: VectorSimilarityTaskInput, oldOutput: VectorSimilarityTaskOutput): Promise<{
+        output: TypedArray[];
+        score: number[];
+    }>;
+}
+export declare const Similarity: (input: VectorSimilarityTaskInput, config?: JobQueueTaskConfig) => Promise<{
+    output: TypedArray[];
+    score: number[];
+}>;
+declare module "@workglow/task-graph" {
+    interface Workflow {
+        Similarity: CreateWorkflow<VectorSimilarityTaskInput, VectorSimilarityTaskOutput, JobQueueTaskConfig>;
+    }
+}
+export declare function inner(arr1: TypedArray, arr2: TypedArray): number;
+export declare function magnitude(arr: TypedArray): number;
+export declare function normalize(vector: TypedArray): TypedArray;
+export {};
+//# sourceMappingURL=VectorSimilarityTask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VectorSimilarityTask.d.ts","sourceRoot":"","sources":["../../src/task/VectorSimilarityTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACH,SAAS,EACT,cAAc,EACd,kBAAkB,EAIrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAoB,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE7F,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE5E,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BQ,CAAC;AAEpC,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBO,CAAC;AAEpC,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAChD,OAAO,qBAAqB,EAC5B,uBAAuB,CACxB,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,UAAU,CACjD,OAAO,sBAAsB,EAC7B,uBAAuB,CACxB,CAAC;AAEF,qBAAa,oBAAqB,SAAQ,SAAS,CACjD,yBAAyB,EACzB,0BAA0B,EAC1B,kBAAkB,CACnB;IACC,MAAM,CAAC,QAAQ,CAAC,IAAI,0BAA0B;IAC9C,MAAM,CAAC,QAAQ,CAAC,QAAQ,cAAc;IACtC,MAAM,CAAC,QAAQ,CAAC,KAAK,uBAAuB;IAC5C,OAAc,WAAW,SACwD;IACjF,MAAM,CAAC,QAAQ,CAAC,SAAS,QAAQ;WAEV,WAAW,IAAI,cAAc;WAG7B,YAAY,IAAI,cAAc;IAK/C,eAAe,CACnB,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,yBAAyB,EAC7D,SAAS,EAAE,0BAA0B;;;;CAsBxC;AAID,eAAO,MAAM,UAAU,GAAI,OAAO,yBAAyB,EAAE,SAAS,kBAAkB;;;EAEvF,CAAC;AAEF,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,QAAQ;QAChB,UAAU,EAAE,cAAc,CACxB,yBAAyB,EACzB,0BAA0B,EAC1B,kBAAkB,CACnB,CAAC;KACH;CACF;AAMD,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAGhE;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,UAAU,UAGxC;AASD,wBAAgB,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAiBxD"}

package/dist/task/base/AiTask.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @description This file contains the implementation of the JobQueueTask class and its derived classes.
+ */
+import { Job, JobQueue } from "@workglow/job-queue";
+import { JobQueueTask, JobQueueTaskConfig, TaskInput, type TaskOutput } from "@workglow/task-graph";
+import { AiJobInput } from "../../job/AiJob";
+import type { Model } from "../../model/Model";
+export interface AiSingleTaskInput extends TaskInput {
+    model: string;
+}
+export interface AiArrayTaskInput extends TaskInput {
+    model: string | string[];
+}
+/**
+ * A base class for AI related tasks that run in a job queue.
+ * Extends the JobQueueTask class to provide LLM-specific functionality.
+ */
+export declare class AiTask<Input extends AiArrayTaskInput = AiArrayTaskInput, Output extends TaskOutput = TaskOutput, Config extends JobQueueTaskConfig = JobQueueTaskConfig> extends JobQueueTask<Input, Output, Config> {
+    static type: string;
+    private modelCache?;
+    /**
+     * Creates a new AiTask instance
+     * @param config - Configuration object for the task
+     */
+    constructor(input?: Input, config?: Config);
+    /**
+     * Creates a new Job instance for the task
+     * @returns Promise<Job> - The created job
+     */
+    createJob(input: Input, queue?: JobQueue<Input, Output>): Promise<Job<AiJobInput<Input>, Output>>;
+    protected getModelForInput(input: AiSingleTaskInput): Promise<Model>;
+    protected getDefaultQueueName(input: Input): Promise<string | undefined>;
+    /**
+     * Validates that a model name really exists
+     * @param schema The schema to validate against
+     * @param item The item to validate
+     * @returns True if the item is valid, false otherwise
+     */
+    validateInput(input: Input): Promise<boolean>;
+    narrowInput(input: Input): Promise<Input>;
+}
+//# sourceMappingURL=AiTask.d.ts.map

package/dist/task/base/AiTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AiTask.d.ts","sourceRoot":"","sources":["../../../src/task/base/AiTask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AAEH,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EACH,YAAY,EACZ,kBAAkB,EAElB,SAAS,EACT,KAAK,UAAU,EAClB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAS,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAS/C,MAAM,WAAW,iBAAkB,SAAQ,SAAS;IAClD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAiB,SAAQ,SAAS;IACjD,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED;;;GAGG;AACH,qBAAa,MAAM,CACjB,KAAK,SAAS,gBAAgB,GAAG,gBAAgB,EACjD,MAAM,SAAS,UAAU,GAAG,UAAU,EACtC,MAAM,SAAS,kBAAkB,GAAG,kBAAkB,CACtD,SAAQ,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC;IAC3C,OAAc,IAAI,EAAE,MAAM,CAAY;IACtC,OAAO,CAAC,UAAU,CAAC,CAAiC;IAEpD;;;OAGG;gBACS,KAAK,GAAE,KAAmB,EAAE,MAAM,GAAE,MAAqB;IAWrE;;;OAGG;IACY,SAAS,CACtB,KAAK,EAAE,KAAK,EACZ,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;cAyB1B,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,KAAK,CAAC;cAcjD,mBAAmB,CAAC,KAAK,EAAE,KAAK;IAQzD;;;;;OAKG;IACG,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC;IA8C7C,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;CA2BhD"}

package/dist/task/base/AiTaskSchemas.d.ts

@@ -0,0 +1,156 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DataPortSchemaNonBoolean, FromSchema, JsonSchema } from "@workglow/util";
+export type TypedArray = Float64Array | Float32Array | Int32Array | Int16Array | Int8Array | Uint32Array | Uint16Array | Uint8Array | Uint8ClampedArray;
+declare const TypedArraySchemaOptions: {
+    readonly deserialize: [{
+        readonly pattern: {
+            readonly format: "TypedArray";
+        };
+        readonly output: TypedArray;
+    }];
+    readonly parseNotKeyword: true;
+    readonly parseIfThenElseKeywords: false;
+    readonly keepDefaultedPropertiesOptional: true;
+    readonly references: false;
+};
+export type TypedArraySchemaOptions = typeof TypedArraySchemaOptions;
+export declare const TypedArraySchema: (annotations?: Record<string, unknown>) => {
+    readonly oneOf: readonly [{
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Float64";
+        };
+        readonly title: "Float64Array";
+        readonly description: "A 64-bit floating point array";
+        readonly format: "Float64Array";
+    }, {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Float32";
+        };
+        readonly title: "Float32Array";
+        readonly description: "A 32-bit floating point array";
+        readonly format: "Float32Array";
+    }, {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Int32";
+        };
+        readonly title: "Int32Array";
+        readonly description: "A 32-bit integer array";
+        readonly format: "Int32Array";
+    }, {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Int16";
+        };
+        readonly title: "Int16Array";
+        readonly description: "A 16-bit integer array";
+        readonly format: "Int16Array";
+    }, {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Int8";
+        };
+        readonly title: "Int8Array";
+    }, {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Uint8";
+        };
+        readonly title: "Uint8Array";
+        readonly description: "A 8-bit unsigned integer array";
+        readonly format: "Uint8Array";
+    }, {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Uint16";
+        };
+        readonly title: "Uint16Array";
+        readonly description: "A 16-bit unsigned integer array";
+        readonly format: "Uint16Array";
+    }, {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Uint32";
+        };
+        readonly title: "Uint32Array";
+        readonly description: "A 32-bit unsigned integer array";
+        readonly format: "Uint32Array";
+    }, {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly format: "Uint8Clamped";
+        };
+        readonly title: "Uint8ClampedArray";
+        readonly description: "A 8-bit unsigned integer array with values clamped to 0-255";
+        readonly format: "Uint8ClampedArray";
+    }];
+    readonly format: "TypedArray";
+};
+export declare const TypeLanguage: (annotations?: Record<string, unknown>) => {
+    readonly type: "string";
+    readonly title: "Language";
+    readonly description: "The language to use";
+    readonly maxLength: 2;
+    readonly minLength: 2;
+};
+export type TypeModelSemantic = "model" | `model:${string}`;
+export type TTypeModel = DataPortSchemaNonBoolean & {
+    readonly type: "string";
+    readonly format: TypeModelSemantic;
+};
+export declare function TypeModel<S extends TypeModelSemantic = "model", O extends Record<string, unknown> = {}>(semantic?: S, options?: O): {
+    readonly title: "Model";
+    readonly description: `The model ${string}`;
+} & O & {
+    readonly format: S;
+    readonly type: "string";
+};
+export declare const TypeReplicateArray: <T extends DataPortSchemaNonBoolean>(type: T, annotations?: Record<string, unknown>) => {
+    readonly "x-replicate": true;
+    readonly format?: string | undefined;
+    readonly oneOf: readonly [T, {
+        readonly type: "array";
+        readonly items: T;
+    }];
+    readonly title: string | undefined;
+    readonly description: string | undefined;
+};
+export type TypedArrayFromSchema<SCHEMA extends JsonSchema> = FromSchema<SCHEMA, TypedArraySchemaOptions>;
+/**
+ * Removes array types from a union, leaving only non-array types.
+ * For example, `string | string[]` becomes `string`.
+ * Used to extract the single-value type from schemas with x-replicate annotation.
+ * Uses distributive conditional types to filter out arrays from unions.
+ * Checks for both array types and types with numeric index signatures (FromSchema array output).
+ * Preserves TypedArray types like Float64Array which also have numeric indices.
+ */
+type UnwrapArrayUnion<T> = T extends readonly any[] ? T extends TypedArray ? T : never : number extends keyof T ? "push" extends keyof T ? never : T : T;
+/**
+ * Transforms a schema by removing array variants from properties marked with x-replicate.
+ * Properties with x-replicate use {@link TypeReplicateArray} which creates a union of
+ * `T | T[]`, and this type extracts just `T`.
+ */
+export type DeReplicateFromSchema<S extends {
+    properties: Record<string, any>;
+}> = {
+    [K in keyof S["properties"]]: S["properties"][K] extends {
+        "x-replicate": true;
+    } ? UnwrapArrayUnion<TypedArrayFromSchema<S["properties"][K]>> : TypedArrayFromSchema<S["properties"][K]>;
+};
+export {};
+//# sourceMappingURL=AiTaskSchemas.d.ts.map

package/dist/task/base/AiTaskSchemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AiTaskSchemas.d.ts","sourceRoot":"","sources":["../../../src/task/base/AiTaskSchemas.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACH,wBAAwB,EACxB,UAAU,EAGV,UAAU,EACb,MAAM,gBAAgB,CAAC;AAExB,MAAM,MAAM,UAAU,GAClB,YAAY,GACZ,YAAY,GACZ,UAAU,GACV,UAAU,GACV,SAAS,GACT,WAAW,GACX,WAAW,GACX,UAAU,GACV,iBAAiB,CAAC;AAKtB,QAAA,MAAM,uBAAuB;;;;;;;;;;;CA2ES,CAAC;AAEvC,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC;AAErE,eAAO,MAAM,gBAAgB,GAAI,cAAa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmExC,CAAC;AAEnC,eAAO,MAAM,YAAY,GAAI,cAAa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;;;;;;CAQzD,CAAC;AAEd,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,SAAS,MAAM,EAAE,CAAC;AAE5D,MAAM,MAAM,UAAU,GAAG,wBAAwB,GAAG;IAClD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;CACpC,CAAC;AAEF,wBAAgB,SAAS,CACvB,CAAC,SAAS,iBAAiB,GAAG,OAAO,EACrC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EACtC,QAAQ,GAAE,CAAgB,EAAE,OAAO,GAAE,CAAW;;;;;;EAkBjD;AAED,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,wBAAwB,EACnE,MAAM,CAAC,EACP,cAAa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;;;;;;;;;CAS9B,CAAC;AAEd,MAAM,MAAM,oBAAoB,CAAC,MAAM,SAAS,UAAU,IAAI,UAAU,CACtE,MAAM,EACN,uBAAuB,CACxB,CAAC;AAEF;;;;;;;GAOG;AACH,KAAK,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,EAAE,GAC/C,CAAC,SAAS,UAAU,GAClB,CAAC,GACD,KAAK,GACP,MAAM,SAAS,MAAM,CAAC,GACpB,MAAM,SAAS,MAAM,CAAC,GACpB,KAAK,GACL,CAAC,GACH,CAAC,CAAC;AAER;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,IAAI;KAChF,CAAC,IAAI,MAAM,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,GAC5E,gBAAgB,CAAC,oBAAoB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAC1D,oBAAoB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;CAC7C,CAAC"}

package/dist/task/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./base/AiTask";
+export * from "./base/AiTaskSchemas";
+export * from "./DocumentSplitterTask";
+export * from "./DownloadModelTask";
+export * from "./TextEmbeddingTask";
+export * from "./TextGenerationTask";
+export * from "./TextQuestionAnswerTask";
+export * from "./TextRewriterTask";
+export * from "./TextSummaryTask";
+export * from "./TextTranslationTask";
+export * from "./VectorSimilarityTask";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/task/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./common";
+export * from "./model/storage/IndexedDbModelRepository";
+export * from "./model/storage/InMemoryModelRepository";
+export * from "./model/storage/PostgresModelRepository";
+export * from "./model/storage/SqliteModelRepository";
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,UAAU,CAAC;AAEzB,cAAc,0CAA0C,CAAC;AACzD,cAAc,yCAAyC,CAAC;AACxD,cAAc,yCAAyC,CAAC;AACxD,cAAc,uCAAuC,CAAC"}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@workglow/ai",
+  "type": "module",
+  "version": "0.0.52",
+  "description": "Core AI functionality for Workglow, including task execution, model management, and AI pipeline orchestration.",
+  "scripts": {
+    "watch": "concurrently -c 'auto' 'bun:watch-*'",
+    "watch-browser": "bun build --watch --no-clear-screen --target=browser --sourcemap=external --packages=external --outdir ./dist ./src/browser.ts",
+    "watch-node": "bun build --watch --no-clear-screen --target=node --sourcemap=external --packages=external --outdir ./dist ./src/node.ts",
+    "watch-bun": "bun build --watch --no-clear-screen --target=bun --sourcemap=external --packages=external --outdir ./dist ./src/bun.ts",
+    "watch-types": "tsc --watch --preserveWatchOutput",
+    "build-package": "bun run build-clean && concurrently -c 'auto' -n 'browser,node,bun,types' 'bun run build-browser' 'bun run build-node' 'bun run build-bun' 'bun run build-types'",
+    "build-clean": "rm -fr dist/*",
+    "build-browser": "bun build --target=browser --sourcemap=external --packages=external --outdir ./dist ./src/browser.ts",
+    "build-node": "bun build --target=node --sourcemap=external --packages=external --outdir ./dist ./src/node.ts",
+    "build-bun": "bun build --target=bun --sourcemap=external --packages=external --outdir ./dist ./src/bun.ts",
+    "build-types": "rm -f tsconfig.tsbuildinfo && tsc",
+    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
+    "test": "bun test",
+    "prepare": "node -e \"const pkg=require('./package.json');pkg.exports['.'].bun='./dist/bun.js';pkg.exports['.'].types='./dist/types.d.ts';require('fs').writeFileSync('package.json',JSON.stringify(pkg,null,2))\""
+  },
+  "exports": {
+    ".": {
+      "react-native": "./dist/browser.js",
+      "browser": "./dist/browser.js",
+      "bun": "./dist/bun.js",
+      "types": "./dist/types.d.ts",
+      "node": "./dist/node.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@workglow/job-queue": "0.0.52",
+    "@workglow/storage": "0.0.52",
+    "@workglow/task-graph": "0.0.52",
+    "@workglow/util": "0.0.52",
+    "pg": "^8.16.3"
+  },
+  "peerDependenciesMeta": {
+    "@workglow/job-queue": {
+      "optional": false
+    },
+    "@workglow/storage": {
+      "optional": false
+    },
+    "@workglow/task-graph": {
+      "optional": false
+    },
+    "@workglow/util": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@workglow/job-queue": "0.0.52",
+    "@workglow/storage": "0.0.52",
+    "@workglow/task-graph": "0.0.52",
+    "@workglow/util": "0.0.52",
+    "@types/pg": "^8.15.5",
+    "pg": "^8.16.3"
+  }
+}