@localmode/transformers 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,992 @@
+import { EmbeddingModel, ClassificationModel, ZeroShotClassificationModel, NERModel, RerankerModel, SpeechToTextModel, ImageClassificationModel, ZeroShotImageClassificationModel, ImageCaptionModel, SegmentationModel, ObjectDetectionModel, ImageFeatureModel, ImageToImageModel, TextToSpeechModel, TranslationModel, SummarizationModel, FillMaskModel, QuestionAnsweringModel, OCRModel, DocumentQAModel, ClassificationResultItem, ClassificationUsage, NERResultItem, NERUsage, RankedDocument, RerankUsage, AudioInput, TranscriptionSegment, AudioUsage, ImageInput, ImageClassificationResultItem, VisionUsage, ZeroShotImageClassificationResultItem } from '@localmode/core';
+
+/**
+ * Transformers Provider Types
+ *
+ * Provider-specific types for the Transformers.js integration.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Supported compute devices for Transformers.js.
+ */
+type TransformersDevice = 'webgpu' | 'wasm' | 'cpu' | 'auto';
+/**
+ * Progress callback for model loading.
+ * Status types include all possible states from the underlying transformers library.
+ */
+interface ModelLoadProgress {
+    /** Current status */
+    status: 'initiate' | 'download' | 'progress' | 'done' | 'ready';
+    /** Model name being loaded */
+    name?: string;
+    /** File being downloaded */
+    file?: string;
+    /** Download progress (0-100) */
+    progress?: number;
+    /** Bytes loaded */
+    loaded?: number;
+    /** Total bytes */
+    total?: number;
+}
+/**
+ * Provider-level settings for all Transformers.js models.
+ */
+interface TransformersProviderSettings {
+    /**
+     * Compute device to use.
+     * @default 'auto' (prefers WebGPU if available, falls back to WASM)
+     */
+    device?: TransformersDevice;
+    /**
+     * Whether to run inference in a Web Worker.
+     * This keeps the main thread responsive during model inference.
+     * @default false
+     */
+    useWorker?: boolean;
+    /**
+     * Progress callback for model loading.
+     */
+    onProgress?: (progress: ModelLoadProgress) => void;
+    /**
+     * Custom cache directory (for Node.js environments).
+     */
+    cacheDir?: string;
+    /**
+     * Whether to use quantized models for smaller size.
+     * @default true
+     */
+    quantized?: boolean;
+}
+/**
+ * Model-level settings that can override provider settings.
+ */
+interface ModelSettings {
+    /**
+     * Override the compute device for this specific model.
+     */
+    device?: TransformersDevice;
+    /**
+     * Override worker usage for this specific model.
+     */
+    useWorker?: boolean;
+    /**
+     * Override quantization for this specific model.
+     */
+    quantized?: boolean;
+    /**
+     * Progress callback for this specific model.
+     */
+    onProgress?: (progress: ModelLoadProgress) => void;
+}
+/**
+ * The Transformers provider interface.
+ *
+ * Provides factory methods for all supported model types.
+ */
+interface TransformersProvider {
+    /**
+     * Create an embedding model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.embedding('Xenova/all-MiniLM-L6-v2');
+     * const { embedding } = await embed({ model, value: 'Hello' });
+     * ```
+     */
+    embedding(modelId: string, settings?: ModelSettings): EmbeddingModel;
+    /**
+     * Create a text classification model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.classifier('Xenova/distilbert-sst-2');
+     * const { label } = await classify({ model, text: 'Great!' });
+     * ```
+     */
+    classifier(modelId: string, settings?: ModelSettings): ClassificationModel;
+    /**
+     * Create a zero-shot classification model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.zeroShot('Xenova/bart-large-mnli');
+     * const { labels } = await classifyZeroShot({
+     *   model,
+     *   text: 'I love pizza',
+     *   candidateLabels: ['food', 'sports', 'politics'],
+     * });
+     * ```
+     */
+    zeroShot(modelId: string, settings?: ModelSettings): ZeroShotClassificationModel;
+    /**
+     * Create a named entity recognition model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.ner('Xenova/bert-base-NER');
+     * const { entities } = await extractEntities({ model, text: 'John works at Google' });
+     * ```
+     */
+    ner(modelId: string, settings?: ModelSettings): NERModel;
+    /**
+     * Create a reranker model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.reranker('Xenova/ms-marco-MiniLM-L-6-v2');
+     * const { results } = await rerank({ model, query: 'What is ML?', documents });
+     * ```
+     */
+    reranker(modelId: string, settings?: ModelSettings): RerankerModel;
+    /**
+     * Create a speech-to-text model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.speechToText('Xenova/whisper-tiny');
+     * const { text } = await transcribe({ model, audio: audioBlob });
+     * ```
+     */
+    speechToText(modelId: string, settings?: ModelSettings): SpeechToTextModel;
+    /**
+     * Create an image classification model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.imageClassifier('Xenova/vit-base-patch16-224');
+     * const { predictions } = await classifyImage({ model, image: imageBlob });
+     * ```
+     */
+    imageClassifier(modelId: string, settings?: ModelSettings): ImageClassificationModel;
+    /**
+     * Create a zero-shot image classification model (e.g., CLIP).
+     *
+     * @example
+     * ```ts
+     * const model = transformers.zeroShotImageClassifier('Xenova/clip-vit-base-patch32');
+     * const { labels, scores } = await classifyImageZeroShot({
+     *   model,
+     *   image: imageBlob,
+     *   candidateLabels: ['cat', 'dog', 'bird'],
+     * });
+     * ```
+     */
+    zeroShotImageClassifier(modelId: string, settings?: ModelSettings): ZeroShotImageClassificationModel;
+    /**
+     * Create an image captioning model (e.g., BLIP).
+     *
+     * @example
+     * ```ts
+     * const model = transformers.captioner('Xenova/blip-image-captioning-base');
+     * const { caption } = await captionImage({ model, image: imageBlob });
+     * ```
+     */
+    captioner(modelId: string, settings?: ModelSettings): ImageCaptionModel;
+    /**
+     * Create an image segmentation model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.segmenter('Xenova/segformer-b0-finetuned-ade-512-512');
+     * const { masks } = await segmentImage({ model, image: imageBlob });
+     * ```
+     */
+    segmenter(modelId: string, settings?: ModelSettings): SegmentationModel;
+    /**
+     * Create an object detection model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.objectDetector('Xenova/detr-resnet-50');
+     * const { objects } = await detectObjects({ model, image: imageBlob });
+     * ```
+     */
+    objectDetector(modelId: string, settings?: ModelSettings): ObjectDetectionModel;
+    /**
+     * Create an image feature extraction model (e.g., CLIP, DINOv2).
+     *
+     * @example
+     * ```ts
+     * const model = transformers.imageFeatures('Xenova/clip-vit-base-patch32');
+     * const { features } = await extractImageFeatures({ model, image: imageBlob });
+     * ```
+     */
+    imageFeatures(modelId: string, settings?: ModelSettings): ImageFeatureModel;
+    /**
+     * Create an image-to-image model (e.g., super resolution).
+     *
+     * @example
+     * ```ts
+     * const model = transformers.imageToImage('Xenova/swin2SR-classical-sr-x2-64');
+     * const { image } = await imageToImage({ model, image: imageBlob });
+     * ```
+     */
+    imageToImage(modelId: string, settings?: ModelSettings): ImageToImageModel;
+    /**
+     * Create a text-to-speech model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.textToSpeech('Xenova/speecht5-tts');
+     * const { audio } = await synthesizeSpeech({ model, text: 'Hello world' });
+     * ```
+     */
+    textToSpeech(modelId: string, settings?: ModelSettings): TextToSpeechModel;
+    /**
+     * Create a translation model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.translator('Xenova/opus-mt-en-de');
+     * const { text } = await translate({ model, text: 'Hello', targetLanguage: 'de' });
+     * ```
+     */
+    translator(modelId: string, settings?: ModelSettings): TranslationModel;
+    /**
+     * Create a summarization model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.summarizer('Xenova/bart-large-cnn');
+     * const { text } = await summarize({ model, text: longText });
+     * ```
+     */
+    summarizer(modelId: string, settings?: ModelSettings): SummarizationModel;
+    /**
+     * Create a fill-mask model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.fillMask('Xenova/bert-base-uncased');
+     * const { predictions } = await fillMask({ model, text: 'The capital of France is [MASK].' });
+     * ```
+     */
+    fillMask(modelId: string, settings?: ModelSettings): FillMaskModel;
+    /**
+     * Create a question answering model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.questionAnswering('Xenova/distilbert-base-cased-distilled-squad');
+     * const { answers } = await answerQuestion({ model, question: 'What is ML?', context });
+     * ```
+     */
+    questionAnswering(modelId: string, settings?: ModelSettings): QuestionAnsweringModel;
+    /**
+     * Create an OCR model (TrOCR).
+     *
+     * @example
+     * ```ts
+     * const model = transformers.ocr('Xenova/trocr-base-handwritten');
+     * const { fullText } = await extractText({ model, image: imageBlob });
+     * ```
+     */
+    ocr(modelId: string, settings?: ModelSettings): OCRModel;
+    /**
+     * Create a document QA model.
+     *
+     * @example
+     * ```ts
+     * const model = transformers.documentQA('Xenova/donut-base-finetuned-docvqa');
+     * const { answers } = await askDocument({ model, question: 'What is the total?', document });
+     * ```
+     */
+    documentQA(modelId: string, settings?: ModelSettings): DocumentQAModel;
+}
+
+/**
+ * Transformers Provider
+ *
+ * Factory for creating Transformers.js model instances.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create a Transformers.js provider with custom settings.
+ *
+ * @param settings - Provider-level settings that apply to all models
+ * @returns A TransformersProvider instance
+ *
+ * @example Basic usage
+ * ```ts
+ * import { createTransformers } from '@localmode/transformers';
+ *
+ * const myTransformers = createTransformers({
+ *   device: 'webgpu',
+ *   onProgress: (p) => console.log(`Loading: ${p.progress}%`),
+ * });
+ *
+ * const embedder = myTransformers.embedding('Xenova/all-MiniLM-L6-v2');
+ * ```
+ *
+ * @example With worker
+ * ```ts
+ * const workerTransformers = createTransformers({
+ *   useWorker: true,
+ * });
+ * ```
+ */
+declare function createTransformers(settings?: TransformersProviderSettings): TransformersProvider;
+/**
+ * Default Transformers.js provider instance.
+ *
+ * Use this for quick access without custom configuration.
+ *
+ * @example
+ * ```ts
+ * import { transformers } from '@localmode/transformers';
+ * import { embed } from '@localmode/core';
+ *
+ * const { embedding } = await embed({
+ *   model: transformers.embedding('Xenova/all-MiniLM-L6-v2'),
+ *   value: 'Hello world',
+ * });
+ * ```
+ */
+declare const transformers: TransformersProvider;
+
+/**
+ * Transformers Utilities
+ *
+ * Utility functions for the Transformers.js provider.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Check if WebGPU is available in the current environment.
+ *
+ * @returns Promise<boolean> True if WebGPU is available
+ *
+ * @example
+ * ```ts
+ * if (await isWebGPUAvailable()) {
+ *   console.log('Using WebGPU for acceleration');
+ * } else {
+ *   console.log('Falling back to WASM');
+ * }
+ * ```
+ */
+declare function isWebGPUAvailable(): Promise<boolean>;
+/**
+ * Get the optimal device based on environment capabilities.
+ *
+ * @returns Promise with the recommended device type
+ */
+declare function getOptimalDevice(): Promise<'webgpu' | 'wasm'>;
+/**
+ * Check if a model is already cached locally.
+ *
+ * @param modelId - The model ID to check
+ * @returns Promise<boolean> True if the model is cached
+ *
+ * @example
+ * ```ts
+ * if (await isModelCached('Xenova/all-MiniLM-L6-v2')) {
+ *   console.log('Model is ready');
+ * } else {
+ *   console.log('Model will be downloaded on first use');
+ * }
+ * ```
+ */
+declare function isModelCached(modelId: string): Promise<boolean>;
+/**
+ * Preload a model to cache it for offline use.
+ *
+ * This downloads and caches the model without actually using it,
+ * allowing for faster subsequent loads.
+ *
+ * @param modelId - The model ID to preload
+ * @param options - Preload options
+ *
+ * @example
+ * ```ts
+ * // Preload during app initialization
+ * await preloadModel('Xenova/all-MiniLM-L6-v2', {
+ *   onProgress: (p) => console.log(`${p.progress}%`),
+ * });
+ * ```
+ */
+declare function preloadModel(modelId: string, options?: {
+    onProgress?: (progress: ModelLoadProgress) => void;
+    quantized?: boolean;
+}): Promise<void>;
+/**
+ * Clear all cached models from the browser.
+ *
+ * @returns Promise<boolean> True if cache was cleared successfully
+ */
+declare function clearModelCache(): Promise<boolean>;
+/**
+ * Get an estimate of cached model storage usage.
+ *
+ * @returns Promise with storage estimate in bytes
+ */
+declare function getModelStorageUsage(): Promise<number>;
+
+/**
+ * Popular Model Constants
+ *
+ * Pre-defined model IDs for commonly used models.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Popular embedding models.
+ */
+declare const EMBEDDING_MODELS: {
+    /** Small, fast, general-purpose embeddings (384 dimensions, ~22MB) */
+    readonly ALL_MINILM_L6_V2: "Xenova/all-MiniLM-L6-v2";
+    /** Multilingual embeddings for 50+ languages (384 dimensions, ~120MB) */
+    readonly PARAPHRASE_MULTILINGUAL_MINILM: "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
+    /** Higher quality but larger (768 dimensions, ~420MB) */
+    readonly ALL_MPNET_BASE_V2: "Xenova/all-mpnet-base-v2";
+    /** BGE embeddings - excellent for RAG (384 dimensions, ~33MB) */
+    readonly BGE_SMALL_EN: "Xenova/bge-small-en-v1.5";
+    /** BGE base model - better quality (768 dimensions, ~110MB) */
+    readonly BGE_BASE_EN: "Xenova/bge-base-en-v1.5";
+};
+/**
+ * Popular text classification models.
+ */
+declare const CLASSIFICATION_MODELS: {
+    /** Fast sentiment analysis (POSITIVE/NEGATIVE) */
+    readonly DISTILBERT_SST2: "Xenova/distilbert-base-uncased-finetuned-sst-2-english";
+    /** Twitter sentiment (positive/neutral/negative) */
+    readonly TWITTER_ROBERTA_SENTIMENT: "Xenova/twitter-roberta-base-sentiment-latest";
+    /** Emotion detection */
+    readonly DISTILROBERTA_EMOTION: "Xenova/distilroberta-base-emotion";
+};
+/**
+ * Popular zero-shot classification models.
+ */
+declare const ZERO_SHOT_MODELS: {
+    /** BART-based zero-shot classification */
+    readonly BART_LARGE_MNLI: "Xenova/bart-large-mnli";
+    /** Smaller, faster zero-shot model */
+    readonly DISTILBART_MNLI: "Xenova/distilbart-mnli-12-3";
+};
+/**
+ * Popular NER (Named Entity Recognition) models.
+ */
+declare const NER_MODELS: {
+    /** Standard NER: PERSON, ORG, LOC, MISC */
+    readonly BERT_BASE_NER: "Xenova/bert-base-NER";
+    /** Multilingual NER */
+    readonly XLM_ROBERTA_NER: "Xenova/xlm-roberta-large-finetuned-conll03-english";
+};
+/**
+ * Popular reranking models.
+ */
+declare const RERANKER_MODELS: {
+    /** Fast, small reranker (~22MB) */
+    readonly MS_MARCO_MINILM_L6: "Xenova/ms-marco-MiniLM-L-6-v2";
+    /** Higher quality reranker */
+    readonly BGE_RERANKER_BASE: "Xenova/bge-reranker-base";
+};
+/**
+ * Popular speech-to-text models.
+ */
+declare const SPEECH_TO_TEXT_MODELS: {
+    /** Smallest Whisper - fastest, good for short audio (~70MB) */
+    readonly WHISPER_TINY: "Xenova/whisper-tiny";
+    /** Small Whisper - better accuracy (~240MB) */
+    readonly WHISPER_SMALL: "Xenova/whisper-small";
+    /** Base Whisper - balanced (~140MB) */
+    readonly WHISPER_BASE: "Xenova/whisper-base";
+    /** Distilled Whisper - fast and accurate */
+    readonly DISTIL_WHISPER_SMALL: "Xenova/distil-whisper-small.en";
+};
+/**
+ * Popular image classification models.
+ */
+declare const IMAGE_CLASSIFICATION_MODELS: {
+    /** ViT base model - ImageNet classes */
+    readonly VIT_BASE_PATCH16: "Xenova/vit-base-patch16-224";
+    /** Smaller ViT model */
+    readonly VIT_SMALL_PATCH16: "Xenova/vit-small-patch16-224";
+    /** ResNet alternative */
+    readonly RESNET_50: "Xenova/resnet-50";
+};
+/**
+ * Popular zero-shot image classification models.
+ */
+declare const ZERO_SHOT_IMAGE_MODELS: {
+    /** CLIP ViT-Base - versatile zero-shot image classification */
+    readonly CLIP_VIT_BASE_PATCH32: "Xenova/clip-vit-base-patch32";
+    /** Larger CLIP model with better accuracy */
+    readonly CLIP_VIT_LARGE_PATCH14: "Xenova/clip-vit-large-patch14";
+    /** SigLIP - improved CLIP variant */
+    readonly SIGLIP_BASE_PATCH16: "Xenova/siglip-base-patch16-224";
+};
+/**
+ * Popular image captioning models.
+ */
+declare const IMAGE_CAPTION_MODELS: {
+    /** BLIP base - fast, good quality captions */
+    readonly BLIP_BASE: "Xenova/blip-image-captioning-base";
+    /** BLIP large - better quality, slower */
+    readonly BLIP_LARGE: "Xenova/blip-image-captioning-large";
+    /** GIT base - alternative captioning model */
+    readonly GIT_BASE: "Xenova/git-base-coco";
+};
+/**
+ * All popular models organized by task.
+ */
+declare const MODELS: {
+    readonly embedding: {
+        /** Small, fast, general-purpose embeddings (384 dimensions, ~22MB) */
+        readonly ALL_MINILM_L6_V2: "Xenova/all-MiniLM-L6-v2";
+        /** Multilingual embeddings for 50+ languages (384 dimensions, ~120MB) */
+        readonly PARAPHRASE_MULTILINGUAL_MINILM: "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
+        /** Higher quality but larger (768 dimensions, ~420MB) */
+        readonly ALL_MPNET_BASE_V2: "Xenova/all-mpnet-base-v2";
+        /** BGE embeddings - excellent for RAG (384 dimensions, ~33MB) */
+        readonly BGE_SMALL_EN: "Xenova/bge-small-en-v1.5";
+        /** BGE base model - better quality (768 dimensions, ~110MB) */
+        readonly BGE_BASE_EN: "Xenova/bge-base-en-v1.5";
+    };
+    readonly classification: {
+        /** Fast sentiment analysis (POSITIVE/NEGATIVE) */
+        readonly DISTILBERT_SST2: "Xenova/distilbert-base-uncased-finetuned-sst-2-english";
+        /** Twitter sentiment (positive/neutral/negative) */
+        readonly TWITTER_ROBERTA_SENTIMENT: "Xenova/twitter-roberta-base-sentiment-latest";
+        /** Emotion detection */
+        readonly DISTILROBERTA_EMOTION: "Xenova/distilroberta-base-emotion";
+    };
+    readonly zeroShot: {
+        /** BART-based zero-shot classification */
+        readonly BART_LARGE_MNLI: "Xenova/bart-large-mnli";
+        /** Smaller, faster zero-shot model */
+        readonly DISTILBART_MNLI: "Xenova/distilbart-mnli-12-3";
+    };
+    readonly ner: {
+        /** Standard NER: PERSON, ORG, LOC, MISC */
+        readonly BERT_BASE_NER: "Xenova/bert-base-NER";
+        /** Multilingual NER */
+        readonly XLM_ROBERTA_NER: "Xenova/xlm-roberta-large-finetuned-conll03-english";
+    };
+    readonly reranker: {
+        /** Fast, small reranker (~22MB) */
+        readonly MS_MARCO_MINILM_L6: "Xenova/ms-marco-MiniLM-L-6-v2";
+        /** Higher quality reranker */
+        readonly BGE_RERANKER_BASE: "Xenova/bge-reranker-base";
+    };
+    readonly speechToText: {
+        /** Smallest Whisper - fastest, good for short audio (~70MB) */
+        readonly WHISPER_TINY: "Xenova/whisper-tiny";
+        /** Small Whisper - better accuracy (~240MB) */
+        readonly WHISPER_SMALL: "Xenova/whisper-small";
+        /** Base Whisper - balanced (~140MB) */
+        readonly WHISPER_BASE: "Xenova/whisper-base";
+        /** Distilled Whisper - fast and accurate */
+        readonly DISTIL_WHISPER_SMALL: "Xenova/distil-whisper-small.en";
+    };
+    readonly imageClassification: {
+        /** ViT base model - ImageNet classes */
+        readonly VIT_BASE_PATCH16: "Xenova/vit-base-patch16-224";
+        /** Smaller ViT model */
+        readonly VIT_SMALL_PATCH16: "Xenova/vit-small-patch16-224";
+        /** ResNet alternative */
+        readonly RESNET_50: "Xenova/resnet-50";
+    };
+    readonly zeroShotImage: {
+        /** CLIP ViT-Base - versatile zero-shot image classification */
+        readonly CLIP_VIT_BASE_PATCH32: "Xenova/clip-vit-base-patch32";
+        /** Larger CLIP model with better accuracy */
+        readonly CLIP_VIT_LARGE_PATCH14: "Xenova/clip-vit-large-patch14";
+        /** SigLIP - improved CLIP variant */
+        readonly SIGLIP_BASE_PATCH16: "Xenova/siglip-base-patch16-224";
+    };
+    readonly imageCaption: {
+        /** BLIP base - fast, good quality captions */
+        readonly BLIP_BASE: "Xenova/blip-image-captioning-base";
+        /** BLIP large - better quality, slower */
+        readonly BLIP_LARGE: "Xenova/blip-image-captioning-large";
+        /** GIT base - alternative captioning model */
+        readonly GIT_BASE: "Xenova/git-base-coco";
+    };
+};
+
+/**
+ * Transformers Embedding Model Implementation
+ *
+ * Implements EmbeddingModel interface using Transformers.js
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Embedding model implementation using Transformers.js
+ */
+declare class TransformersEmbeddingModel implements EmbeddingModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    readonly dimensions: number;
+    readonly maxEmbeddingsPerCall = 128;
+    readonly supportsParallelCalls = false;
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    /**
+     * Estimate dimensions from model ID.
+     */
+    private getDimensionsFromModelId;
+    /**
+     * Load the pipeline if not already loaded.
+     */
+    private loadPipeline;
+    doEmbed(options: {
+        values: string[];
+        abortSignal?: AbortSignal;
+        headers?: Record<string, string>;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        embeddings: Float32Array[];
+        usage: {
+            tokens: number;
+        };
+        response: {
+            id?: string;
+            modelId: string;
+            timestamp: Date;
+        };
+    }>;
+}
+
+/**
+ * Transformers Classification Model Implementation
+ *
+ * Implements ClassificationModel interface using Transformers.js
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Text classification model implementation using Transformers.js
+ */
+declare class TransformersClassificationModel implements ClassificationModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    readonly labels: string[];
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    private loadPipeline;
+    doClassify(options: {
+        texts: string[];
+        abortSignal?: AbortSignal;
+        headers?: Record<string, string>;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        results: ClassificationResultItem[];
+        usage: ClassificationUsage;
+    }>;
+}
+
+/**
+ * Transformers Zero-Shot Classification Model Implementation
+ *
+ * Implements ZeroShotClassificationModel interface using Transformers.js
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Zero-shot classification model implementation using Transformers.js
+ */
+declare class TransformersZeroShotModel implements ZeroShotClassificationModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    private loadPipeline;
+    doClassifyZeroShot(options: {
+        texts: string[];
+        candidateLabels: string[];
+        multiLabel?: boolean;
+        abortSignal?: AbortSignal;
+        headers?: Record<string, string>;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        results: Array<{
+            labels: string[];
+            scores: number[];
+        }>;
+        usage: ClassificationUsage;
+    }>;
+}
+
+/**
+ * Transformers NER Model Implementation
+ *
+ * Implements NERModel interface using Transformers.js
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * NER model implementation using Transformers.js
+ */
+declare class TransformersNERModel implements NERModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    readonly entityTypes: string[];
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    private loadPipeline;
+    doExtract(options: {
+        texts: string[];
+        abortSignal?: AbortSignal;
+        headers?: Record<string, string>;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        results: NERResultItem[];
+        usage: NERUsage;
+    }>;
+}
+
+/**
+ * Transformers Reranker Model Implementation
+ *
+ * Implements RerankerModel interface using Transformers.js
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Reranker model implementation using Transformers.js
+ *
+ * Rerankers score query-document pairs for relevance. They're typically
+ * used after initial retrieval to improve result quality.
+ */
+declare class TransformersRerankerModel implements RerankerModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    private loadPipeline;
+    doRerank(options: {
+        query: string;
+        documents: string[];
+        topK?: number;
+        abortSignal?: AbortSignal;
+        headers?: Record<string, string>;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        results: RankedDocument[];
+        usage: RerankUsage;
+    }>;
+}
+
+/**
+ * Transformers Speech-to-Text Model Implementation
+ *
+ * Implements SpeechToTextModel interface using Transformers.js
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Speech-to-text model implementation using Transformers.js (Whisper)
+ */
+declare class TransformersSpeechToTextModel implements SpeechToTextModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    readonly languages: string[];
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    private loadPipeline;
+    private objectUrls;
+    /**
+     * Convert Float32Array PCM samples to a WAV blob URL.
+     * This ensures transformers.js correctly interprets the audio format.
+     */
+    private createWavUrl;
+    /**
+     * Convert AudioInput to a format Transformers.js can process.
+     * For raw PCM samples, converts to WAV URL to ensure correct interpretation.
+     */
+    private prepareAudio;
+    /**
+     * Cleanup any created Object URLs
+     */
+    private cleanupObjectUrls;
+    doTranscribe(options: {
+        audio: AudioInput;
+        language?: string;
+        task?: 'transcribe' | 'translate';
+        returnTimestamps?: boolean | 'word';
+        abortSignal?: AbortSignal;
+        headers?: Record<string, string>;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        text: string;
+        segments?: TranscriptionSegment[];
+        language?: string;
+        usage: AudioUsage;
+    }>;
+}
+
+/**
+ * Transformers Image Classification Model Implementation
+ *
+ * Implements ImageClassificationModel interface using Transformers.js
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Image classification model implementation using Transformers.js
+ */
+declare class TransformersImageClassificationModel implements ImageClassificationModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    private loadPipeline;
+    /**
+     * Convert ImageInput to a format Transformers.js can process
+     */
+    private prepareImage;
+    doClassify(options: {
+        images: ImageInput[];
+        topK?: number;
+        abortSignal?: AbortSignal;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        results: ImageClassificationResultItem[][];
+        usage: VisionUsage;
+    }>;
+}
+
+/**
+ * Transformers Zero-Shot Image Classification Model Implementation
+ *
+ * Implements ZeroShotImageClassificationModel interface using Transformers.js (CLIP)
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Zero-shot image classification model implementation using Transformers.js (CLIP)
+ */
+declare class TransformersZeroShotImageModel implements ZeroShotImageClassificationModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    private loadPipeline;
+    /**
+     * Convert ImageInput to a format Transformers.js can process
+     */
+    private prepareImage;
+    doClassifyZeroShot(options: {
+        images: ImageInput[];
+        candidateLabels: string[];
+        hypothesisTemplate?: string;
+        abortSignal?: AbortSignal;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        results: ZeroShotImageClassificationResultItem[];
+        usage: VisionUsage;
+    }>;
+}
+
+/**
+ * Transformers Image Captioning Model Implementation
+ *
+ * Implements ImageCaptionModel interface using Transformers.js (BLIP)
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Image captioning model implementation using Transformers.js (BLIP)
+ */
+declare class TransformersCaptionModel implements ImageCaptionModel {
+    private baseModelId;
+    private settings;
+    readonly modelId: string;
+    readonly provider = "transformers";
+    private pipeline;
+    private loadPromise;
+    constructor(baseModelId: string, settings?: {
+        device?: TransformersDevice;
+        quantized?: boolean;
+        onProgress?: (progress: ModelLoadProgress) => void;
+    });
+    private loadPipeline;
+    /**
+     * Convert ImageInput to a format Transformers.js can process
+     */
+    private prepareImage;
+    doCaption(options: {
+        images: ImageInput[];
+        maxLength?: number;
+        abortSignal?: AbortSignal;
+        providerOptions?: Record<string, Record<string, unknown>>;
+    }): Promise<{
+        captions: string[];
+        usage: VisionUsage;
+    }>;
+}
+
+export { CLASSIFICATION_MODELS, EMBEDDING_MODELS, IMAGE_CAPTION_MODELS, IMAGE_CLASSIFICATION_MODELS, MODELS, type ModelLoadProgress, type ModelSettings, NER_MODELS, RERANKER_MODELS, SPEECH_TO_TEXT_MODELS, TransformersCaptionModel, TransformersClassificationModel, type TransformersDevice, TransformersEmbeddingModel, TransformersImageClassificationModel, TransformersNERModel, type TransformersProvider, type TransformersProviderSettings, TransformersRerankerModel, TransformersSpeechToTextModel, TransformersZeroShotImageModel, TransformersZeroShotModel, ZERO_SHOT_IMAGE_MODELS, ZERO_SHOT_MODELS, clearModelCache, createTransformers, getModelStorageUsage, getOptimalDevice, isModelCached, isWebGPUAvailable, preloadModel, transformers };