@workglow/ai-provider 0.0.121 → 0.0.122

package/dist/provider-hf-transformers/common/HFT_JobRunFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_JobRunFns.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_JobRunFns.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AA6BvE;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBZ,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,MAAM,EACN,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,6BAA6B,CAAC,CAS5D,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CACrC,MAAM,EACN,uBAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,6BAA6B,CAAC,CAGjE,CAAC"}

package/dist/provider-hf-transformers/common/HFT_ModelInfo.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, ModelInfoTaskInput, ModelInfoTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+export declare const HFT_ModelInfo: AiProviderRunFn<ModelInfoTaskInput, ModelInfoTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_ModelInfo.d.ts.map

package/dist/provider-hf-transformers/common/HFT_ModelInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_ModelInfo.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_ModelInfo.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAE7F,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAIvE,eAAO,MAAM,aAAa,EAAE,eAAe,CACzC,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,CA2E9B,CAAC"}

package/dist/{hf-transformers → provider-hf-transformers}/common/HFT_ModelSchema.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2025 Steven Roussey <sroussey@gmail.com>
  * SPDX-License-Identifier: Apache-2.0
  */
-import { FromSchema } from "@workglow/util";
+import { FromSchema } from "@workglow/util/worker";
 export declare const HfTransformersOnnxModelSchema: {
     readonly type: "object";
     readonly properties: {
@@ -17,7 +17,7 @@ export declare const HfTransformersOnnxModelSchema: {
             readonly properties: {
                 readonly pipeline: {
                     readonly type: "string";
-                    readonly enum: ("fill-mask" | "token-classification" | "text-generation" | "text2text-generation" | "text-classification" | "summarization" | "translation" | "feature-extraction" | "zero-shot-classification" | "question-answering" | "background-removal" | "image-segmentation" | "depth-estimation" | "image-classification" | "image-to-image" | "object-detection" | "image-feature-extraction" | "audio-classification" | "automatic-speech-recognition" | "text-to-speech" | "document-question-answering" | "image-to-text" | "zero-shot-audio-classification" | "zero-shot-image-classification" | "zero-shot-object-detection")[];
+                    readonly enum: ("audio-classification" | "automatic-speech-recognition" | "background-removal" | "depth-estimation" | "document-question-answering" | "feature-extraction" | "fill-mask" | "image-classification" | "image-feature-extraction" | "image-segmentation" | "image-to-image" | "image-to-text" | "object-detection" | "question-answering" | "summarization" | "text-classification" | "text-generation" | "text-to-speech" | "text2text-generation" | "token-classification" | "translation" | "zero-shot-audio-classification" | "zero-shot-classification" | "zero-shot-image-classification" | "zero-shot-object-detection")[];
                     readonly description: "Pipeline type for the ONNX model.";
                     readonly default: "text-generation";
                 };
@@ -27,7 +27,7 @@ export declare const HfTransformersOnnxModelSchema: {
                 };
                 readonly dtype: {
                     readonly type: "string";
-                    readonly enum: ("auto" | "fp32" | "fp16" | "q8" | "int8" | "uint8" | "q4" | "bnb4" | "q4f16")[];
+                    readonly enum: ("auto" | "bnb4" | "fp16" | "fp32" | "int8" | "q4" | "q4f16" | "q8" | "uint8")[];
                     readonly description: "Data type for the ONNX model.";
                     readonly default: "auto";
                 };
@@ -102,6 +102,28 @@ export declare const HfTransformersOnnxModelSchema: {
 export declare const HfTransformersOnnxModelRecordSchema: {
     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 metadata: {
+            readonly type: "object";
+            readonly default: {};
+            readonly "x-ui-hidden": true;
+        };
         readonly provider: {
             readonly const: "HF_TRANSFORMERS_ONNX";
             readonly description: "Discriminator: ONNX runtime backend.";
@@ -112,7 +134,7 @@ export declare const HfTransformersOnnxModelRecordSchema: {
             readonly properties: {
                 readonly pipeline: {
                     readonly type: "string";
-                    readonly enum: ("fill-mask" | "token-classification" | "text-generation" | "text2text-generation" | "text-classification" | "summarization" | "translation" | "feature-extraction" | "zero-shot-classification" | "question-answering" | "background-removal" | "image-segmentation" | "depth-estimation" | "image-classification" | "image-to-image" | "object-detection" | "image-feature-extraction" | "audio-classification" | "automatic-speech-recognition" | "text-to-speech" | "document-question-answering" | "image-to-text" | "zero-shot-audio-classification" | "zero-shot-image-classification" | "zero-shot-object-detection")[];
+                    readonly enum: ("audio-classification" | "automatic-speech-recognition" | "background-removal" | "depth-estimation" | "document-question-answering" | "feature-extraction" | "fill-mask" | "image-classification" | "image-feature-extraction" | "image-segmentation" | "image-to-image" | "image-to-text" | "object-detection" | "question-answering" | "summarization" | "text-classification" | "text-generation" | "text-to-speech" | "text2text-generation" | "token-classification" | "translation" | "zero-shot-audio-classification" | "zero-shot-classification" | "zero-shot-image-classification" | "zero-shot-object-detection")[];
                     readonly description: "Pipeline type for the ONNX model.";
                     readonly default: "text-generation";
                 };
@@ -122,7 +144,7 @@ export declare const HfTransformersOnnxModelRecordSchema: {
                 };
                 readonly dtype: {
                     readonly type: "string";
-                    readonly enum: ("auto" | "fp32" | "fp16" | "q8" | "int8" | "uint8" | "q4" | "bnb4" | "q4f16")[];
+                    readonly enum: ("auto" | "bnb4" | "fp16" | "fp32" | "int8" | "q4" | "q4f16" | "q8" | "uint8")[];
                     readonly description: "Data type for the ONNX model.";
                     readonly default: "auto";
                 };
@@ -190,6 +212,14 @@ export declare const HfTransformersOnnxModelRecordSchema: {
                 readonly required: readonly ["native_dimensions"];
             };
         };
+    };
+    readonly required: readonly ["model_id", "tasks", "provider", "title", "description", "provider_config", "metadata", "provider", "provider_config"];
+    readonly additionalProperties: false;
+};
+export type HfTransformersOnnxModelRecord = FromSchema<typeof HfTransformersOnnxModelRecordSchema>;
+export declare const HfTransformersOnnxModelConfigSchema: {
+    readonly type: "object";
+    readonly properties: {
         readonly model_id: {
             readonly type: "string";
         };
@@ -212,14 +242,6 @@ export declare const HfTransformersOnnxModelRecordSchema: {
             readonly default: {};
             readonly "x-ui-hidden": true;
         };
-    };
-    readonly required: readonly ["model_id", "tasks", "provider", "title", "description", "provider_config", "metadata", "provider", "provider_config"];
-    readonly additionalProperties: false;
-};
-export type HfTransformersOnnxModelRecord = FromSchema<typeof HfTransformersOnnxModelRecordSchema>;
-export declare const HfTransformersOnnxModelConfigSchema: {
-    readonly type: "object";
-    readonly properties: {
         readonly provider: {
             readonly const: "HF_TRANSFORMERS_ONNX";
             readonly description: "Discriminator: ONNX runtime backend.";
@@ -230,7 +252,7 @@ export declare const HfTransformersOnnxModelConfigSchema: {
             readonly properties: {
                 readonly pipeline: {
                     readonly type: "string";
-                    readonly enum: ("fill-mask" | "token-classification" | "text-generation" | "text2text-generation" | "text-classification" | "summarization" | "translation" | "feature-extraction" | "zero-shot-classification" | "question-answering" | "background-removal" | "image-segmentation" | "depth-estimation" | "image-classification" | "image-to-image" | "object-detection" | "image-feature-extraction" | "audio-classification" | "automatic-speech-recognition" | "text-to-speech" | "document-question-answering" | "image-to-text" | "zero-shot-audio-classification" | "zero-shot-image-classification" | "zero-shot-object-detection")[];
+                    readonly enum: ("audio-classification" | "automatic-speech-recognition" | "background-removal" | "depth-estimation" | "document-question-answering" | "feature-extraction" | "fill-mask" | "image-classification" | "image-feature-extraction" | "image-segmentation" | "image-to-image" | "image-to-text" | "object-detection" | "question-answering" | "summarization" | "text-classification" | "text-generation" | "text-to-speech" | "text2text-generation" | "token-classification" | "translation" | "zero-shot-audio-classification" | "zero-shot-classification" | "zero-shot-image-classification" | "zero-shot-object-detection")[];
                     readonly description: "Pipeline type for the ONNX model.";
                     readonly default: "text-generation";
                 };
@@ -240,7 +262,7 @@ export declare const HfTransformersOnnxModelConfigSchema: {
                 };
                 readonly dtype: {
                     readonly type: "string";
-                    readonly enum: ("auto" | "fp32" | "fp16" | "q8" | "int8" | "uint8" | "q4" | "bnb4" | "q4f16")[];
+                    readonly enum: ("auto" | "bnb4" | "fp16" | "fp32" | "int8" | "q4" | "q4f16" | "q8" | "uint8")[];
                     readonly description: "Data type for the ONNX model.";
                     readonly default: "auto";
                 };
@@ -308,28 +330,6 @@ export declare const HfTransformersOnnxModelConfigSchema: {
                 readonly required: readonly ["native_dimensions"];
             };
         };
-        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 metadata: {
-            readonly type: "object";
-            readonly default: {};
-            readonly "x-ui-hidden": true;
-        };
     };
     readonly required: readonly ["provider", "provider_config", "provider", "provider_config"];
     readonly additionalProperties: false;

package/dist/provider-hf-transformers/common/HFT_ModelSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_ModelSchema.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_ModelSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAwB,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGzE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FD,CAAC;AAE1C,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQP,CAAC;AAE1C,MAAM,MAAM,6BAA6B,GAAG,UAAU,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEnG,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQP,CAAC;AAE1C,MAAM,MAAM,6BAA6B,GAAG,UAAU,CAAC,OAAO,mCAAmC,CAAC,CAAC"}

package/dist/provider-hf-transformers/common/HFT_ModelSearch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, ModelSearchTaskInput, ModelSearchTaskOutput } from "@workglow/ai";
+export declare const HFT_ModelSearch: AiProviderRunFn<ModelSearchTaskInput, ModelSearchTaskOutput>;
+//# sourceMappingURL=HFT_ModelSearch.d.ts.map

package/dist/provider-hf-transformers/common/HFT_ModelSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_ModelSearch.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_ModelSearch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAKjG,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,oBAAoB,EACpB,qBAAqB,CA8BtB,CAAC"}

package/dist/provider-hf-transformers/common/HFT_ObjectDetection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, ObjectDetectionTaskInput, ObjectDetectionTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Core implementation for object detection using Hugging Face Transformers.
+ * Auto-selects between regular and zero-shot detection.
+ */
+export declare const HFT_ObjectDetection: AiProviderRunFn<ObjectDetectionTaskInput, ObjectDetectionTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_ObjectDetection.d.ts.map

package/dist/provider-hf-transformers/common/HFT_ObjectDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_ObjectDetection.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_ObjectDetection.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EACV,eAAe,EACf,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAGvE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAAe,CAC/C,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,CAyC9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_OnnxDtypes.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const ONNX_QUANTIZATION_SUFFIX_MAPPING: {
+    readonly fp32: "";
+    readonly fp16: "_fp16";
+    readonly int8: "_int8";
+    readonly uint8: "_uint8";
+    readonly q8: "_quantized";
+    readonly q4: "_q4";
+    readonly q4f16: "_q4f16";
+    readonly bnb4: "_bnb4";
+};
+export type OnnxQuantization = keyof typeof ONNX_QUANTIZATION_SUFFIX_MAPPING;
+export declare function parseOnnxQuantizations(params: {
+    /** File paths, e.g. from listModels/modelInfo with additionalFields: ["filePaths"] */
+    filePaths: string[];
+    /** Subdirectory containing ONNX files. @default "onnx" */
+    subfolder?: string;
+}): OnnxQuantization[];
+//# sourceMappingURL=HFT_OnnxDtypes.d.ts.map

package/dist/provider-hf-transformers/common/HFT_OnnxDtypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_OnnxDtypes.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_OnnxDtypes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;CASnC,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,gCAAgC,CAAC;AAM7E,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,sFAAsF;IACtF,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,gBAAgB,EAAE,CA6CrB"}

package/dist/provider-hf-transformers/common/HFT_Pipeline.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PretrainedModelOptions } from "@huggingface/transformers";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Set the filesystem cache directory for downloaded transformers.js models.
+ * Must be called before any model is loaded. Works in both Node and browser.
+ */
+export declare function setHftCacheDir(dir: string): void;
+export declare function loadTransformersSDK(): Promise<typeof import("@huggingface/transformers")>;
+/**
+ * Clear all cached pipelines
+ */
+export declare function clearPipelineCache(): void;
+export declare function hasCachedPipeline(cacheKey: string): boolean;
+export declare function removeCachedPipeline(cacheKey: string): boolean;
+/**
+ * Generate a cache key for a pipeline that includes all configuration options
+ * that affect pipeline creation (model_path, pipeline, dtype, device)
+ */
+export declare function getPipelineCacheKey(model: HfTransformersOnnxModelConfig): string;
+/**
+ * Helper function to get a pipeline for a model
+ * @param progressScaleMax - Maximum progress value for download phase (100 for download-only, 10 for download+run)
+ *
+ * Explicit `Promise<any>` return avoids TS2883 (inferred type not portable across package boundaries).
+ */
+export declare function getPipeline(model: HfTransformersOnnxModelConfig, onProgress: (progress: number, message?: string, details?: any) => void, options?: PretrainedModelOptions, signal?: AbortSignal, progressScaleMax?: number): Promise<any>;
+//# sourceMappingURL=HFT_Pipeline.d.ts.map

package/dist/provider-hf-transformers/common/HFT_Pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_Pipeline.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_Pipeline.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAgB,MAAM,2BAA2B,CAAC;AAEtF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAKvE;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAKhD;AAED,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,cAAc,2BAA2B,CAAC,CAAC,CAe/F;AA0BD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE9D;AAOD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,6BAA6B,GAAG,MAAM,CAIhF;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,6BAA6B,EACpC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,EACvE,OAAO,GAAE,sBAA2B,EACpC,MAAM,CAAC,EAAE,WAAW,EACpB,gBAAgB,GAAE,MAAW,GAC5B,OAAO,CAAC,GAAG,CAAC,CA6Bd"}

package/dist/provider-hf-transformers/common/HFT_Streaming.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { StreamEvent } from "@workglow/task-graph";
+export type StreamEventQueue<T> = {
+    push: (event: T) => void;
+    done: () => void;
+    error: (err: Error) => void;
+    iterable: AsyncIterable<T>;
+};
+export declare function createStreamEventQueue<T>(): StreamEventQueue<T>;
+/**
+ * Creates a TextStreamer that pushes StreamEvents into an async queue.
+ * The pipeline runs to completion and updates the queue; the caller
+ * consumes the queue as an AsyncIterable<StreamEvent>.
+ */
+export declare function createStreamingTextStreamer(tokenizer: any, queue: StreamEventQueue<StreamEvent<any>>, transformers: typeof import("@huggingface/transformers")): import("@huggingface/transformers").TextStreamer;
+/**
+ * Create a text streamer for a given tokenizer and update progress function
+ */
+export declare function createTextStreamer(tokenizer: any, updateProgress: (progress: number, message?: string, details?: any) => void, transformers: typeof import("@huggingface/transformers")): import("@huggingface/transformers").TextStreamer;
+//# sourceMappingURL=HFT_Streaming.d.ts.map

package/dist/provider-hf-transformers/common/HFT_Streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_Streaming.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_Streaming.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAChC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACzB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;IAC5B,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CAC5B,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAsD/D;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,GAAG,EACd,KAAK,EAAE,gBAAgB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,EACzC,YAAY,EAAE,cAAc,2BAA2B,CAAC,oDAUzD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,GAAG,EACd,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,EAC3E,YAAY,EAAE,cAAc,2BAA2B,CAAC,oDAczD"}

package/dist/provider-hf-transformers/common/HFT_StructuredGeneration.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, AiProviderStreamFn, StructuredGenerationTaskInput, StructuredGenerationTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+export declare const HFT_StructuredGeneration: AiProviderRunFn<StructuredGenerationTaskInput, StructuredGenerationTaskOutput, HfTransformersOnnxModelConfig>;
+export declare const HFT_StructuredGeneration_Stream: AiProviderStreamFn<StructuredGenerationTaskInput, StructuredGenerationTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_StructuredGeneration.d.ts.map

package/dist/provider-hf-transformers/common/HFT_StructuredGeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_StructuredGeneration.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_StructuredGeneration.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,6BAA6B,EAC7B,8BAA8B,EAC/B,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAoCvE,eAAO,MAAM,wBAAwB,EAAE,eAAe,CACpD,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,CAiC9B,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,kBAAkB,CAC9D,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,CA4D9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextClassification.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, TextClassificationTaskInput, TextClassificationTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+export declare const HFT_TextClassification: AiProviderRunFn<TextClassificationTaskInput, TextClassificationTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextClassification.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextClassification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextClassification.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextClassification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EACV,eAAe,EACf,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAGvE,eAAO,MAAM,sBAAsB,EAAE,eAAe,CAClD,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,CAoF9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextEmbedding.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, TextEmbeddingTaskInput, TextEmbeddingTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Core implementation for text embedding using Hugging Face Transformers.
+ * This is shared between inline and worker implementations.
+ */
+export declare const HFT_TextEmbedding: AiProviderRunFn<TextEmbeddingTaskInput, TextEmbeddingTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextEmbedding.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextEmbedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextEmbedding.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextEmbedding.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAGvE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAAe,CAC7C,sBAAsB,EACtB,uBAAuB,EACvB,6BAA6B,CA2E9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextFillMask.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, TextFillMaskTaskInput, TextFillMaskTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+export declare const HFT_TextFillMask: AiProviderRunFn<TextFillMaskTaskInput, TextFillMaskTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextFillMask.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextFillMask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextFillMask.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextFillMask.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACnG,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAGvE,eAAO,MAAM,gBAAgB,EAAE,eAAe,CAC5C,qBAAqB,EACrB,sBAAsB,EACtB,6BAA6B,CAiC9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextGeneration.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, AiProviderStreamFn, TextGenerationTaskInput, TextGenerationTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Core implementation for text generation using Hugging Face Transformers.
+ * This is shared between inline and worker implementations.
+ */
+export declare const HFT_TextGeneration: AiProviderRunFn<TextGenerationTaskInput, TextGenerationTaskOutput, HfTransformersOnnxModelConfig>;
+export declare const HFT_TextGeneration_Stream: AiProviderStreamFn<TextGenerationTaskInput, TextGenerationTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextGeneration.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextGeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextGeneration.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextGeneration.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AASvE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAAe,CAC9C,uBAAuB,EACvB,wBAAwB,EACxB,6BAA6B,CA2C9B,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,kBAAkB,CACxD,uBAAuB,EACvB,wBAAwB,EACxB,6BAA6B,CAmB9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextLanguageDetection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, TextLanguageDetectionTaskInput, TextLanguageDetectionTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+export declare const HFT_TextLanguageDetection: AiProviderRunFn<TextLanguageDetectionTaskInput, TextLanguageDetectionTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextLanguageDetection.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextLanguageDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextLanguageDetection.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextLanguageDetection.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EACV,eAAe,EACf,8BAA8B,EAC9B,+BAA+B,EAChC,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAGvE,eAAO,MAAM,yBAAyB,EAAE,eAAe,CACrD,8BAA8B,EAC9B,+BAA+B,EAC/B,6BAA6B,CAyC9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextNamedEntityRecognition.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, TextNamedEntityRecognitionTaskInput, TextNamedEntityRecognitionTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+export declare const HFT_TextNamedEntityRecognition: AiProviderRunFn<TextNamedEntityRecognitionTaskInput, TextNamedEntityRecognitionTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextNamedEntityRecognition.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextNamedEntityRecognition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextNamedEntityRecognition.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextNamedEntityRecognition.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EACV,eAAe,EACf,mCAAmC,EACnC,oCAAoC,EACrC,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAGvE,eAAO,MAAM,8BAA8B,EAAE,eAAe,CAC1D,mCAAmC,EACnC,oCAAoC,EACpC,6BAA6B,CAwC9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextOutput.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Message } from "@huggingface/transformers";
+export declare function extractGeneratedText(generatedText: string | Message[] | undefined): string;
+//# sourceMappingURL=HFT_TextOutput.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextOutput.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextOutput.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,SAAS,GAAG,MAAM,CAa1F"}

package/dist/provider-hf-transformers/common/HFT_TextQuestionAnswer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, AiProviderStreamFn, TextQuestionAnswerTaskInput, TextQuestionAnswerTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Core implementation for question answering using Hugging Face Transformers.
+ * This is shared between inline and worker implementations.
+ */
+export declare const HFT_TextQuestionAnswer: AiProviderRunFn<TextQuestionAnswerTaskInput, TextQuestionAnswerTaskOutput, HfTransformersOnnxModelConfig>;
+export declare const HFT_TextQuestionAnswer_Stream: AiProviderStreamFn<TextQuestionAnswerTaskInput, TextQuestionAnswerTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextQuestionAnswer.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextQuestionAnswer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextQuestionAnswer.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextQuestionAnswer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAQvE;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAAe,CAClD,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,CAyD9B,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAC5D,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,CAgD9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextRewriter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, AiProviderStreamFn, TextRewriterTaskInput, TextRewriterTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Core implementation for text rewriting using Hugging Face Transformers.
+ * This is shared between inline and worker implementations.
+ */
+export declare const HFT_TextRewriter: AiProviderRunFn<TextRewriterTaskInput, TextRewriterTaskOutput, HfTransformersOnnxModelConfig>;
+export declare const HFT_TextRewriter_Stream: AiProviderStreamFn<TextRewriterTaskInput, TextRewriterTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextRewriter.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextRewriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextRewriter.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextRewriter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AASvE;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,eAAe,CAC5C,qBAAqB,EACrB,sBAAsB,EACtB,6BAA6B,CAiD9B,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,kBAAkB,CACtD,qBAAqB,EACrB,sBAAsB,EACtB,6BAA6B,CAqB9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextSummary.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, AiProviderStreamFn, TextSummaryTaskInput, TextSummaryTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Core implementation for text summarization using Hugging Face Transformers.
+ * This is shared between inline and worker implementations.
+ */
+export declare const HFT_TextSummary: AiProviderRunFn<TextSummaryTaskInput, TextSummaryTaskOutput, HfTransformersOnnxModelConfig>;
+export declare const HFT_TextSummary_Stream: AiProviderStreamFn<TextSummaryTaskInput, TextSummaryTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextSummary.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextSummary.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextSummary.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAQvE;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,oBAAoB,EACpB,qBAAqB,EACrB,6BAA6B,CAkC9B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CACrD,oBAAoB,EACpB,qBAAqB,EACrB,6BAA6B,CA2B9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_TextTranslation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, AiProviderStreamFn, TextTranslationTaskInput, TextTranslationTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Core implementation for text translation using Hugging Face Transformers.
+ * This is shared between inline and worker implementations.
+ */
+export declare const HFT_TextTranslation: AiProviderRunFn<TextTranslationTaskInput, TextTranslationTaskOutput, HfTransformersOnnxModelConfig>;
+export declare const HFT_TextTranslation_Stream: AiProviderStreamFn<TextTranslationTaskInput, TextTranslationTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_TextTranslation.d.ts.map

package/dist/provider-hf-transformers/common/HFT_TextTranslation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_TextTranslation.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_TextTranslation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAQvE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAAe,CAC/C,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,CAmC9B,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CACzD,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,CAwB9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_ToolCalling.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, AiProviderStreamFn, ToolCallingTaskInput, ToolCallingTaskOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+export declare const HFT_ToolCalling: AiProviderRunFn<ToolCallingTaskInput, ToolCallingTaskOutput, HfTransformersOnnxModelConfig>;
+export declare const HFT_ToolCalling_Stream: AiProviderStreamFn<ToolCallingTaskInput, ToolCallingTaskOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_ToolCalling.d.ts.map

package/dist/provider-hf-transformers/common/HFT_ToolCalling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_ToolCalling.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_ToolCalling.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EAEtB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AA2DvE,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,oBAAoB,EACpB,qBAAqB,EACrB,6BAA6B,CAwF9B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CACrD,oBAAoB,EACpB,qBAAqB,EACrB,6BAA6B,CAkF9B,CAAC"}

package/dist/provider-hf-transformers/common/HFT_ToolMarkup.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ToolCalls } from "@workglow/ai";
+/**
+ * Parse tool calls from model-generated text.
+ *
+ * Many instruct models (Qwen, Llama, Hermes, etc.) emit tool calls in one of
+ * these formats:
+ *
+ * 1. `<tool_call>{"name":"fn","arguments":{...}}</tool_call>` (Qwen/Hermes)
+ * 2. Plain JSON objects with a "name" + "arguments" key
+ * 3. `{"function":{"name":"fn","arguments":{...}}}`
+ *
+ * This function extracts all such tool calls from the raw response text
+ * and returns both the cleaned text (with tool-call markup removed) and
+ * the parsed ToolCall array.
+ */
+export declare function parseToolCallsFromText(responseText: string): {
+    text: string;
+    toolCalls: ToolCalls;
+};
+/**
+ * State machine that filters `<tool_call>…</tool_call>` markup out of a
+ * stream of text-delta tokens. Tokens that are clearly outside markup are
+ * flushed immediately; tokens that *might* be the start of a tag are held
+ * in a lookahead buffer until they can be disambiguated.
+ *
+ * This only handles the XML-tag pattern (Pattern 1 in parseToolCallsFromText).
+ * Bare-JSON tool calls (Pattern 2) cannot be reliably detected token-by-token
+ * and are still cleaned up via the post-hoc `parseToolCallsFromText` pass on
+ * the finish event.
+ */
+export declare function createToolCallMarkupFilter(emit: (text: string) => void): {
+    feed: (token: string) => void;
+    flush: () => void;
+};
+//# sourceMappingURL=HFT_ToolMarkup.d.ts.map

package/dist/provider-hf-transformers/common/HFT_ToolMarkup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_ToolMarkup.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_ToolMarkup.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,SAAS,CAAC;CACtB,CA2HA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;;;EAsFtE"}

package/dist/provider-hf-transformers/common/HFT_Unload.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRunFn, UnloadModelTaskRunInput, UnloadModelTaskRunOutput } from "@workglow/ai";
+import type { HfTransformersOnnxModelConfig } from "./HFT_ModelSchema";
+/**
+ * Core implementation for unloading a Hugging Face Transformers model.
+ * This is shared between inline and worker implementations.
+ */
+export declare const HFT_Unload: AiProviderRunFn<UnloadModelTaskRunInput, UnloadModelTaskRunOutput, HfTransformersOnnxModelConfig>;
+//# sourceMappingURL=HFT_Unload.d.ts.map

package/dist/provider-hf-transformers/common/HFT_Unload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HFT_Unload.d.ts","sourceRoot":"","sources":["../../../src/provider-hf-transformers/common/HFT_Unload.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAsDvE;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,eAAe,CACtC,uBAAuB,EACvB,wBAAwB,EACxB,6BAA6B,CAmB9B,CAAC"}