@huggingface/transformers 3.0.0-alpha.0

package/types/generation/logits_process.d.ts

@@ -0,0 +1,354 @@
+declare const LogitsProcessor_base: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+/**
+ * Abstract base class for all logit processors that can be applied during generation.
+ */
+export class LogitsProcessor extends LogitsProcessor_base {
+    /**
+     * Apply the processor to the input logits.
+     *
+     * @abstract
+     * @param {bigint[][]} input_ids The input ids.
+     * @param {Tensor} logits The logits to process.
+     * @throws {Error} Throws an error if `_call` is not implemented in the subclass.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): void;
+}
+declare const LogitsWarper_base: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+/**
+ * Abstract base class for all logit warpers that can be applied during generation with multinomial sampling.
+ */
+export class LogitsWarper extends LogitsWarper_base {
+    /**
+     * Apply the processor to the input logits.
+     *
+     * @abstract
+     * @param {bigint[][]} input_ids The input ids.
+     * @param {Tensor} logits The logits to process.
+     * @throws {Error} Throws an error if `_call` is not implemented in the subclass.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): void;
+}
+declare const LogitsProcessorList_base: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+/**
+ * A class representing a list of logits processors. A logits processor is a function that modifies the logits
+ * output of a language model. This class provides methods for adding new processors and applying all processors to a
+ * batch of logits.
+ */
+export class LogitsProcessorList extends LogitsProcessorList_base {
+    processors: any[];
+    /**
+     * Adds a new logits processor to the list.
+     *
+     * @param {LogitsProcessor} item The logits processor function to add.
+     */
+    push(item: LogitsProcessor): void;
+    /**
+     * Adds multiple logits processors to the list.
+     *
+     * @param {LogitsProcessor[]} items The logits processor functions to add.
+     */
+    extend(items: LogitsProcessor[]): void;
+    /**
+     * Applies all logits processors in the list to a batch of logits, modifying them in-place.
+     *
+     * @param {bigint[][]} input_ids The input IDs for the language model.
+     * @param {Tensor} logits
+     */
+    _call(input_ids: bigint[][], logits: Tensor): Tensor;
+    [Symbol.iterator](): IterableIterator<any>;
+}
+/**
+ * A LogitsProcessor that forces a BOS token at the beginning of the generated sequence.
+ */
+export class ForcedBOSTokenLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a ForcedBOSTokenLogitsProcessor.
+     * @param {number} bos_token_id The ID of the beginning-of-sequence token to be forced.
+     */
+    constructor(bos_token_id: number);
+    bos_token_id: number;
+    /**
+     * Apply the BOS token forcing to the logits.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The logits with BOS token forcing.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+/**
+ * A logits processor that enforces the specified token as the last generated token when `max_length` is reached.
+ */
+export class ForcedEOSTokenLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a ForcedEOSTokenLogitsProcessor.
+     * @param {number} max_length The maximum length of the sequence to be generated.
+     * @param {number|number[]} eos_token_id The id(s) of the *end-of-sequence* token.
+     */
+    constructor(max_length: number, eos_token_id: number | number[]);
+    max_length: number;
+    eos_token_id: number[];
+    /**
+     * Apply the processor to input_ids and logits.
+     *
+     * @param {bigint[][]} input_ids The input ids.
+     * @param {Tensor} logits The logits tensor.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): Tensor;
+}
+/**
+ * A LogitsProcessor that suppresses a list of tokens as soon as the `generate` function starts
+ * generating using `begin_index` tokens. This should ensure that the tokens defined by
+ * `begin_suppress_tokens` at not sampled at the begining of the generation.
+ */
+export class SuppressTokensAtBeginLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a SuppressTokensAtBeginLogitsProcessor.
+     * @param {number[]} begin_suppress_tokens The IDs of the tokens to suppress.
+     * @param {number} begin_index The number of tokens to generate before suppressing tokens.
+     */
+    constructor(begin_suppress_tokens: number[], begin_index: number);
+    begin_suppress_tokens: number[];
+    begin_index: number;
+    /**
+     * Apply the BOS token forcing to the logits.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The logits with BOS token forcing.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+/**
+ * A LogitsProcessor that handles adding timestamps to generated text.
+ */
+export class WhisperTimeStampLogitsProcessor extends LogitsProcessor {
+    /**
+     * Constructs a new WhisperTimeStampLogitsProcessor.
+     * @param {import('../models/whisper/generation_whisper.js').WhisperGenerationConfig} generate_config The config object passed to the `generate()` method of a transformer model.
+     * @param {number[]} init_tokens The initial tokens of the input sequence.
+     */
+    constructor(generate_config: import('../models/whisper/generation_whisper.js').WhisperGenerationConfig, init_tokens: number[]);
+    eos_token_id: number;
+    no_timestamps_token_id: number;
+    timestamp_begin: number;
+    begin_index: number;
+    max_initial_timestamp_index: number;
+    /**
+     * Modify the logits to handle timestamp tokens.
+     * @param {bigint[][]} input_ids The input sequence of tokens.
+     * @param {Tensor} logits The logits output by the model.
+     * @returns {Tensor} The modified logits.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): Tensor;
+}
+/**
+ * A logits processor that disallows ngrams of a certain size to be repeated.
+ */
+export class NoRepeatNGramLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a NoRepeatNGramLogitsProcessor.
+     * @param {number} no_repeat_ngram_size The no-repeat-ngram size. All ngrams of this size can only occur once.
+     */
+    constructor(no_repeat_ngram_size: number);
+    no_repeat_ngram_size: number;
+    /**
+     * Generate n-grams from a sequence of token ids.
+     * @param {bigint[]} prevInputIds List of previous input ids
+     * @returns {Map<string, number[]>} Map of generated n-grams
+     */
+    getNgrams(prevInputIds: bigint[]): Map<string, number[]>;
+    /**
+     * Generate n-grams from a sequence of token ids.
+     * @param {Map<string, number[]>} bannedNgrams Map of banned n-grams
+     * @param {bigint[]} prevInputIds List of previous input ids
+     * @returns {number[]} Map of generated n-grams
+     */
+    getGeneratedNgrams(bannedNgrams: Map<string, number[]>, prevInputIds: bigint[]): number[];
+    /**
+     * Calculate banned n-gram tokens
+     * @param {bigint[]} prevInputIds List of previous input ids
+     * @returns {number[]} Map of generated n-grams
+     */
+    calcBannedNgramTokens(prevInputIds: bigint[]): number[];
+    /**
+     * Apply the no-repeat-ngram processor to the logits.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The logits with no-repeat-ngram processing.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+/**
+ * A logits processor that penalises repeated output tokens.
+ */
+export class RepetitionPenaltyLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a RepetitionPenaltyLogitsProcessor.
+     * @param {number} penalty The penalty to apply for repeated tokens.
+     */
+    constructor(penalty: number);
+    penalty: number;
+    /**
+     * Apply the repetition penalty to the logits.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The logits with repetition penalty processing.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+/**
+ * A logits processor that enforces a minimum number of tokens.
+ */
+export class MinLengthLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a MinLengthLogitsProcessor.
+     * @param {number} min_length The minimum length below which the score of `eos_token_id` is set to negative infinity.
+     * @param {number|number[]} eos_token_id The ID/IDs of the end-of-sequence token.
+     */
+    constructor(min_length: number, eos_token_id: number | number[]);
+    min_length: number;
+    eos_token_id: number[];
+    /**
+     * Apply logit processor.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The processed logits.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+/**
+ * A logits processor that enforces a minimum number of new tokens.
+ */
+export class MinNewTokensLengthLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a MinNewTokensLengthLogitsProcessor.
+     * @param {number} prompt_length_to_skip The input tokens length.
+     * @param {number} min_new_tokens The minimum *new* tokens length below which the score of `eos_token_id` is set to negative infinity.
+     * @param {number|number[]} eos_token_id The ID/IDs of the end-of-sequence token.
+     */
+    constructor(prompt_length_to_skip: number, min_new_tokens: number, eos_token_id: number | number[]);
+    prompt_length_to_skip: number;
+    min_new_tokens: number;
+    eos_token_id: number[];
+    /**
+     * Apply logit processor.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The processed logits.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+export class NoBadWordsLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a `NoBadWordsLogitsProcessor`.
+     * @param {number[][]} bad_words_ids List of list of token ids that are not allowed to be generated.
+     * @param {number|number[]} eos_token_id The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.
+     */
+    constructor(bad_words_ids: number[][], eos_token_id: number | number[]);
+    bad_words_ids: number[][];
+    eos_token_id: number[];
+    /**
+     * Apply logit processor.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The processed logits.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+/**
+ * [`LogitsProcessor`] for classifier free guidance (CFG). The scores are split over the batch dimension,
+ * where the first half correspond to the conditional logits (predicted from the input prompt) and the second half
+ * correspond to the unconditional logits (predicted from an empty or 'null' prompt). The processor computes a
+ * weighted average across the conditional and unconditional logits, parameterised by the `guidance_scale`.
+ *
+ * See [the paper](https://arxiv.org/abs/2306.05284) for more information.
+ */
+export class ClassifierFreeGuidanceLogitsProcessor extends LogitsProcessor {
+    /**
+     * Create a `ClassifierFreeGuidanceLogitsProcessor`.
+     * @param {number} guidance_scale The guidance scale for classifier free guidance (CFG). CFG is enabled by setting `guidance_scale > 1`.
+     * Higher guidance scale encourages the model to generate samples that are more closely linked to the input
+     * prompt, usually at the expense of poorer quality.
+     */
+    constructor(guidance_scale: number);
+    guidance_scale: number;
+    /**
+     * Apply logit processor.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The processed logits.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+/**
+ * [`LogitsWarper`] for temperature (exponential scaling output probability distribution), which effectively means
+ * that it can control the randomness of the predicted tokens. Often used together with [`TopPLogitsWarper`] and [`TopKLogitsWarper`].
+ */
+export class TemperatureLogitsWarper extends LogitsWarper {
+    /**
+     * Create a `TemperatureLogitsWarper`.
+     * @param {number} temperature Strictly positive float value used to modulate the logits distribution.
+     * A value smaller than `1` decreases randomness (and vice versa), with `0` being equivalent to shifting
+     * all probability mass to the most likely token.
+     */
+    constructor(temperature: number);
+    temperature: number;
+    /**
+     * Apply logit warper.
+     * @param {bigint[][]} input_ids The input IDs.
+     * @param {Tensor} logits The logits.
+     * @returns {Object} The processed logits.
+     */
+    _call(input_ids: bigint[][], logits: Tensor): any;
+}
+/**
+ * [`LogitsWarper`] that performs top-p, i.e. restricting to top tokens summing to prob_cut_off <= prob_cut_off.
+ * Often used together with [`TemperatureLogitsWarper`] and [`TopKLogitsWarper`].
+ */
+export class TopPLogitsWarper extends LogitsWarper {
+    /**
+     * Create a `TopPLogitsWarper`.
+     * @param {number} top_p If set to < 1, only the smallest set of most probable tokens with
+     * probabilities that add up to `top_p` or higher are kept for generation.
+     * @param {Object} options Additional options for the top-p sampling.
+     * @param {number} [options.filter_value=-Infinity] All filtered values will be set to this float value.
+     * @param {number} [options.min_tokens_to_keep=1] Minimum number of tokens that cannot be filtered.
+     */
+    constructor(top_p: number, { filter_value, min_tokens_to_keep, }?: {
+        filter_value?: number;
+        min_tokens_to_keep?: number;
+    });
+    top_p: number;
+    filter_value: number;
+    min_tokens_to_keep: number;
+}
+/**
+ * [`LogitsWarper`] that performs top-k, i.e. restricting to the k highest probability elements.
+ * Often used together with [`TemperatureLogitsWarper`] and [`TopPLogitsWarper`].
+ */
+export class TopKLogitsWarper extends LogitsWarper {
+    /**
+     * Create a `TopKLogitsWarper`.
+     * @param {number} top_k If set to > 0, only the top `top_k` tokens are kept for generation.
+     * @param {Object} options Additional options for the top-k sampling.
+     * @param {number} [options.filter_value=-Infinity] All filtered values will be set to this float value.
+     * @param {number} [options.min_tokens_to_keep=1] Minimum number of tokens that cannot be filtered.
+     */
+    constructor(top_k: number, { filter_value, min_tokens_to_keep, }?: {
+        filter_value?: number;
+        min_tokens_to_keep?: number;
+    });
+    top_k: number;
+    filter_value: number;
+}
+import { Tensor } from "../utils/tensor.js";
+export {};
+//# sourceMappingURL=logits_process.d.ts.map

package/types/generation/logits_process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logits_process.d.ts","sourceRoot":"","sources":["../../src/generation/logits_process.js"],"names":[],"mappings":"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"}

package/types/generation/logits_sampler.d.ts

@@ -0,0 +1,51 @@
+declare const LogitsSampler_base: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+/**
+ * Sampler is a base class for all sampling methods used for text generation.
+ */
+export class LogitsSampler extends LogitsSampler_base {
+    /**
+     * Returns a Sampler object based on the specified options.
+     * @param {GenerationConfig} generation_config An object containing options for the sampler.
+     * @returns {LogitsSampler} A Sampler object.
+     */
+    static getSampler(generation_config: GenerationConfig): LogitsSampler;
+    /**
+     * Creates a new Sampler object with the specified generation config.
+     * @param {GenerationConfig} generation_config The generation config.
+     */
+    constructor(generation_config: GenerationConfig);
+    generation_config: GenerationConfig;
+    /**
+     * Executes the sampler, using the specified logits.
+     * @param {Tensor} logits
+     * @returns {Promise<[bigint, number][]>}
+     */
+    _call(logits: Tensor): Promise<[bigint, number][]>;
+    /**
+     * Abstract method for sampling the logits.
+     * @param {Tensor} logits
+     * @throws {Error} If not implemented in subclass.
+     * @returns {Promise<[bigint, number][]>}
+     */
+    sample(logits: Tensor): Promise<[bigint, number][]>;
+    /**
+     * Returns the specified logits as an array, with temperature applied.
+     * @param {Tensor} logits
+     * @param {number} index
+     * @returns {Float32Array}
+     */
+    getLogits(logits: Tensor, index: number): Float32Array;
+    /**
+     * Selects an item randomly based on the specified probabilities.
+     * @param {import("../transformers.js").DataArray} probabilities An array of probabilities to use for selection.
+     * @returns {number} The index of the selected item.
+     */
+    randomSelect(probabilities: import("../transformers.js").DataArray): number;
+}
+import { GenerationConfig } from '../generation/configuration_utils.js';
+import { Tensor } from "../utils/tensor.js";
+export {};
+//# sourceMappingURL=logits_sampler.d.ts.map

package/types/generation/logits_sampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logits_sampler.d.ts","sourceRoot":"","sources":["../../src/generation/logits_sampler.js"],"names":[],"mappings":";;;;AAcA;;GAEG;AACH;IAyEI;;;;OAIG;IACH,qCAHW,gBAAgB,GACd,aAAa,CAwBzB;IAnGD;;;OAGG;IACH,+BAFW,gBAAgB,EAK1B;IADG,oCAA0C;IAG9C;;;;OAIG;IACH,cAHW,MAAM,GACJ,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAMvC;IAED;;;;;OAKG;IACH,eAJW,MAAM,GAEJ,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAIvC;IAED;;;;;OAKG;IACH,kBAJW,MAAM,SACN,MAAM,GACJ,YAAY,CAcxB;IAED;;;;OAIG;IACH,4BAHW,OAAO,oBAAoB,EAAE,SAAS,GACpC,MAAM,CAiBlB;CA8BJ;iCA1GgC,sCAAsC;uBAN1C,oBAAoB"}

package/types/generation/parameters.d.ts

@@ -0,0 +1,47 @@
+type GenerationFunctionParameters = {
+    /**
+     * (`Tensor` of varying shape depending on the modality, *optional*):
+     * The sequence used as a prompt for the generation or as model inputs to the encoder. If `null` the
+     * method initializes it with `bos_token_id` and a batch size of 1. For decoder-only models `inputs`
+     * should be in the format of `input_ids`. For encoder-decoder models *inputs* can represent any of
+     * `input_ids`, `input_values`, `input_features`, or `pixel_values`.
+     */
+    inputs?: import('../utils/tensor.js').Tensor;
+    /**
+     * (`GenerationConfig`, *optional*):
+     * The generation configuration to be used as base parametrization for the generation call.
+     * `**kwargs` passed to generate matching the attributes of `generation_config` will override them.
+     * If `generation_config` is not provided, the default will be used, which has the following loading
+     * priority:
+     * - (1) from the `generation_config.json` model file, if it exists;
+     * - (2) from the model configuration. Please note that unspecified parameters will inherit [`GenerationConfig`]'s
+     * default values, whose documentation should be checked to parameterize generation.
+     */
+    generation_config?: import('./configuration_utils.js').GenerationConfig;
+    /**
+     * (`LogitsProcessorList`, *optional*):
+     * Custom logits processors that complement the default logits processors built from arguments and
+     * generation config. If a logit processor is passed that is already created with the arguments or a
+     * generation config an error is thrown. This feature is intended for advanced users.
+     */
+    logits_processor?: import('./logits_process.js').LogitsProcessorList;
+    /**
+     * (`StoppingCriteriaList`, *optional*):
+     * Custom stopping criteria that complements the default stopping criteria built from arguments and a
+     * generation config. If a stopping criteria is passed that is already created with the arguments or a
+     * generation config an error is thrown. This feature is intended for advanced users.
+     */
+    stopping_criteria?: import('./stopping_criteria.js').StoppingCriteriaList;
+    /**
+     * (`BaseStreamer`, *optional*):
+     * Streamer object that will be used to stream the generated sequences. Generated tokens are passed
+     * through `streamer.put(token_ids)` and the streamer is responsible for any further processing.
+     */
+    streamer?: import('./streamers.js').BaseStreamer;
+    /**
+     * (`number[]`, *optional*):
+     * If the model is an encoder-decoder model, this argument is used to pass the `decoder_input_ids`.
+     */
+    decoder_input_ids?: number[];
+};
+//# sourceMappingURL=parameters.d.ts.map

package/types/generation/parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../src/generation/parameters.js"],"names":[],"mappings":";;;;;;;;aAOc,OAAO,oBAAoB,EAAE,MAAM;;;;;;;;;;;wBAKnC,OAAO,0BAA0B,EAAE,gBAAgB;;;;;;;uBAQnD,OAAO,qBAAqB,EAAE,mBAAmB;;;;;;;wBAIjD,OAAO,wBAAwB,EAAE,oBAAoB;;;;;;eAIrD,OAAO,gBAAgB,EAAE,YAAY;;;;;wBAGrC,MAAM,EAAE"}

package/types/generation/stopping_criteria.d.ts

@@ -0,0 +1,81 @@
+declare const StoppingCriteria_base: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+/**
+ * Abstract base class for all stopping criteria that can be applied during generation.
+ */
+export class StoppingCriteria extends StoppingCriteria_base {
+    /**
+     *
+     * @param {number[][]} input_ids (`number[][]` of shape `(batch_size, sequence_length)`):
+     * Indices of input sequence tokens in the vocabulary.
+     * @param {number[][]} scores scores (`number[][]` of shape `(batch_size, config.vocab_size)`):
+     * Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax
+     * or scores for each vocabulary token after SoftMax.
+     * @returns {boolean[]} A list of booleans indicating whether each sequence should be stopped.
+     */
+    _call(input_ids: number[][], scores: number[][]): boolean[];
+}
+declare const StoppingCriteriaList_base: new () => {
+    (...args: any[]): any;
+    _call(...args: any[]): any;
+};
+/**
+ */
+export class StoppingCriteriaList extends StoppingCriteriaList_base {
+    criteria: any[];
+    /**
+     * Adds a new stopping criterion to the list.
+     *
+     * @param {StoppingCriteria} item The stopping criterion to add.
+     */
+    push(item: StoppingCriteria): void;
+    /**
+     * Adds multiple stopping criteria to the list.
+     *
+     * @param {StoppingCriteria|StoppingCriteriaList|StoppingCriteria[]} items The stopping criteria to add.
+     */
+    extend(items: StoppingCriteria | StoppingCriteriaList | StoppingCriteria[]): void;
+    _call(input_ids: any, scores: any): any[];
+    [Symbol.iterator](): IterableIterator<any>;
+}
+/**
+ * This class can be used to stop generation whenever the full generated number of tokens exceeds `max_length`.
+ * Keep in mind for decoder-only type of transformers, this will include the initial prompted tokens.
+ */
+export class MaxLengthCriteria extends StoppingCriteria {
+    /**
+     *
+     * @param {number} max_length The maximum length that the output sequence can have in number of tokens.
+     * @param {number} [max_position_embeddings=null] The maximum model length, as defined by the model's `config.max_position_embeddings` attribute.
+     */
+    constructor(max_length: number, max_position_embeddings?: number);
+    max_length: number;
+    max_position_embeddings: number;
+    _call(input_ids: any): any;
+}
+/**
+ * This class can be used to stop generation whenever the "end-of-sequence" token is generated.
+ * By default, it uses the `model.generation_config.eos_token_id`.
+ */
+export class EosTokenCriteria extends StoppingCriteria {
+    /**
+     *
+     * @param {number|number[]} eos_token_id The id of the *end-of-sequence* token.
+     * Optionally, use a list to set multiple *end-of-sequence* tokens.
+     */
+    constructor(eos_token_id: number | number[]);
+    eos_token_id: number[];
+}
+/**
+ * This class can be used to stop generation whenever the user interrupts the process.
+ */
+export class InterruptableStoppingCriteria extends StoppingCriteria {
+    interrupted: boolean;
+    interrupt(): void;
+    reset(): void;
+    _call(input_ids: any, scores: any): any[];
+}
+export {};
+//# sourceMappingURL=stopping_criteria.d.ts.map

package/types/generation/stopping_criteria.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stopping_criteria.d.ts","sourceRoot":"","sources":["../../src/generation/stopping_criteria.js"],"names":[],"mappings":";;;;AAUA;;GAEG;AACH;IACI;;;;;;;;OAQG;IACH,iBAPW,MAAM,EAAE,EAAE,UAEV,MAAM,EAAE,EAAE,GAGR,OAAO,EAAE,CAIrB;CACJ;;;;;AACD;GACG;AACH;IAMQ,gBAAkB;IAGtB;;;;OAIG;IACH,WAFW,gBAAgB,QAI1B;IAED;;;;OAIG;IACH,cAFW,gBAAgB,GAAC,oBAAoB,GAAC,gBAAgB,EAAE,QASlE;IAED,0CASC;IAED,2CAEC;CACJ;AAED;;;GAGG;AACH;IAEI;;;;OAIG;IACH,wBAHW,MAAM,4BACN,MAAM,EAMhB;IAFG,mBAA4B;IAC5B,gCAAsD;IAG1D,2BAEC;CACJ;AAID;;;GAGG;AACH;IAEI;;;;OAIG;IACH,0BAHW,MAAM,GAAC,MAAM,EAAE,EASzB;IADG,uBAAgC;CAgBvC;AAED;;GAEG;AACH;IAGQ,qBAAwB;IAG5B,kBAEC;IAED,cAEC;IAED,0CAEC;CACJ"}

package/types/generation/streamers.d.ts

@@ -0,0 +1,81 @@
+export class BaseStreamer {
+    /**
+     * Function that is called by `.generate()` to push new tokens
+     * @param {bigint[][]} value
+     */
+    put(value: bigint[][]): void;
+    /**
+     * Function that is called by `.generate()` to signal the end of generation
+     */
+    end(): void;
+}
+/**
+ * Simple text streamer that prints the token(s) to stdout as soon as entire words are formed.
+ */
+export class TextStreamer extends BaseStreamer {
+    /**
+     *
+     * @param {import('../tokenizers.js').PreTrainedTokenizer} tokenizer
+     */
+    constructor(tokenizer: import('../tokenizers.js').PreTrainedTokenizer, { skip_prompt, callback_function, token_callback_function, decode_kwargs, ...kwargs }?: {
+        skip_prompt?: boolean;
+        callback_function?: any;
+        token_callback_function?: any;
+        decode_kwargs?: {};
+    });
+    tokenizer: import("../tokenizers.js").PreTrainedTokenizer;
+    skip_prompt: boolean;
+    callback_function: any;
+    token_callback_function: any;
+    decode_kwargs: {};
+    token_cache: any[];
+    print_len: number;
+    next_tokens_are_prompt: boolean;
+    /**
+     * Prints the new text to stdout. If the stream is ending, also prints a newline.
+     * @param {string} text
+     * @param {boolean} stream_end
+     */
+    on_finalized_text(text: string, stream_end: boolean): void;
+}
+/**
+ * Utility class to handle streaming of tokens generated by whisper speech-to-text models.
+ * Callback functions are invoked when each of the following events occur:
+ *  - A new chunk starts (on_chunk_start)
+ *  - A new token is generated (callback_function)
+ *  - A chunk ends (on_chunk_end)
+ *  - The stream is finalized (on_finalize)
+ */
+export class WhisperTextStreamer extends TextStreamer {
+    /**
+     * @param {import('../tokenizers.js').WhisperTokenizer} tokenizer
+     * @param {Object} options
+     * @param {boolean} [options.skip_prompt=false] Whether to skip the prompt tokens
+     * @param {function(string): void} [options.callback_function=null] Function to call when a piece of text is ready to display
+     * @param {function(string): void} [options.token_callback_function=null] Function to call when a new token is generated
+     * @param {function(number): void} [options.on_chunk_start=null] Function to call when a new chunk starts
+     * @param {function(number): void} [options.on_chunk_end=null] Function to call when a chunk ends
+     * @param {function(): void} [options.on_finalize=null] Function to call when the stream is finalized
+     * @param {number} [options.time_precision=0.02] Precision of the timestamps
+     * @param {boolean} [options.skip_special_tokens=true] Whether to skip special tokens when decoding
+     * @param {Object} [options.decode_kwargs={}] Additional keyword arguments to pass to the tokenizer's decode method
+     */
+    constructor(tokenizer: import('../tokenizers.js').WhisperTokenizer, { skip_prompt, callback_function, token_callback_function, on_chunk_start, on_chunk_end, on_finalize, time_precision, skip_special_tokens, decode_kwargs, }?: {
+        skip_prompt?: boolean;
+        callback_function?: (arg0: string) => void;
+        token_callback_function?: (arg0: string) => void;
+        on_chunk_start?: (arg0: number) => void;
+        on_chunk_end?: (arg0: number) => void;
+        on_finalize?: () => void;
+        time_precision?: number;
+        skip_special_tokens?: boolean;
+        decode_kwargs?: any;
+    });
+    timestamp_begin: number;
+    on_chunk_start: (arg0: number) => void;
+    on_chunk_end: (arg0: number) => void;
+    on_finalize: () => void;
+    time_precision: number;
+    waiting_for_timestamp: boolean;
+}
+//# sourceMappingURL=streamers.d.ts.map

package/types/generation/streamers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamers.d.ts","sourceRoot":"","sources":["../../src/generation/streamers.js"],"names":[],"mappings":"AASA;IACI;;;OAGG;IACH,WAFW,MAAM,EAAE,EAAE,QAIpB;IAED;;OAEG;IACH,YAEC;CACJ;AAMD;;GAEG;AACH;IACI;;;OAGG;IACH,uBAFW,OAAO,kBAAkB,EAAE,mBAAmB;;;;;OAoBxD;IAVG,0DAA0B;IAC1B,qBAA8B;IAC9B,uBAA0D;IAC1D,6BAAsD;IACtD,kBAAoD;IAGpD,mBAAqB;IACrB,kBAAkB;IAClB,gCAAkC;IA6DtC;;;;OAIG;IACH,wBAHW,MAAM,cACN,OAAO,QASjB;CACJ;AAED;;;;;;;GAOG;AACH;IACI;;;;;;;;;;;;OAYG;IACH,uBAZW,OAAO,kBAAkB,EAAE,gBAAgB;QAEzB,WAAW,GAA7B,OAAO;QAC0B,iBAAiB,UAAzC,MAAM,KAAG,IAAI;QACW,uBAAuB,UAA/C,MAAM,KAAG,IAAI;QACW,cAAc,UAAtC,MAAM,KAAG,IAAI;QACW,YAAY,UAApC,MAAM,KAAG,IAAI;QACK,WAAW,SAA1B,IAAI;QACC,cAAc,GAA/B,MAAM;QACY,mBAAmB,GAArC,OAAO;QACU,aAAa;OA4BxC;IATG,wBAAgD;IAEhD,uBA1BgB,MAAM,KAAG,IAAI,CA0BO;IACpC,qBA1BgB,MAAM,KAAG,IAAI,CA0BG;IAChC,mBA1BmB,IAAI,CA0BO;IAE9B,uBAAoC;IAEpC,+BAAkC;CAiCzC"}

package/types/models/whisper/common_whisper.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {string} language The language name or code
+ * @returns {string} The language code
+ */
+export function whisper_language_to_code(language: string): string;
+export const WHISPER_LANGUAGE_MAPPING: Map<any, any>;
+export const WHISPER_TO_LANGUAGE_CODE_MAPPING: Map<any, any>;
+//# sourceMappingURL=common_whisper.d.ts.map

package/types/models/whisper/common_whisper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common_whisper.d.ts","sourceRoot":"","sources":["../../../src/models/whisper/common_whisper.js"],"names":[],"mappings":"AA4HA;;;GAGG;AACH,mDAHW,MAAM,GACJ,MAAM,CAwBlB;AA7CD,qDAAmE;AAEnE,6DAeG"}